@elizaos/plugin-sql 1.6.5-alpha.2 → 1.6.5-alpha.20

package/dist/node/index.node.js

@@ -5694,6 +5694,44 @@ var init_drizzle_orm = __esm(() => {
   init_view_common();
 });
 
+// src/schema/agent.ts
+var agentTable;
+var init_agent = __esm(() => {
+  init_drizzle_orm();
+  init_pg_core();
+  agentTable = pgTable("agents", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    enabled: boolean("enabled").default(true).notNull(),
+    server_id: uuid("server_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    name: text("name").notNull(),
+    username: text("username"),
+    system: text("system").default(""),
+    bio: jsonb("bio").$type().default(sql`'[]'::jsonb`),
+    messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    topics: jsonb("topics").$type().default(sql`'[]'::jsonb`).notNull(),
+    adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`).notNull(),
+    knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`).notNull(),
+    plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`).notNull(),
+    settings: jsonb("settings").$type().default(sql`'{}'::jsonb`).notNull(),
+    style: jsonb("style").$type().default(sql`'{}'::jsonb`).notNull()
+  });
+});
+
+// src/schema/server.ts
+var serverTable;
+var init_server = __esm(() => {
+  init_drizzle_orm();
+  init_pg_core();
+  serverTable = pgTable("servers", {
+    id: uuid("id").primaryKey(),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull()
+  });
+});
+
 // src/runtime-migrator/storage/migration-tracker.ts
 class MigrationTracker {
   db;
@@ -5871,14 +5909,14 @@ class ExtensionManager {
     for (const extension of extensions) {
       try {
         if (!/^[a-zA-Z0-9_-]+$/.test(extension)) {
-          logger2.warn(`[RuntimeMigrator] Invalid extension name "${extension}" - contains invalid characters`);
+          logger2.warn({ src: "plugin:sql", extension }, "Invalid extension name - contains invalid characters");
           continue;
         }
         await this.db.execute(sql`CREATE EXTENSION IF NOT EXISTS ${sql.identifier(extension)}`);
-        logger2.debug(`[RuntimeMigrator] Extension installed: ${extension}`);
+        logger2.debug({ src: "plugin:sql", extension }, "Extension installed");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger2.warn(`[RuntimeMigrator] Could not install extension ${extension}: ${errorMessage}`);
+        logger2.warn({ src: "plugin:sql", extension, error: errorMessage }, "Could not install extension");
       }
     }
   }
@@ -6590,10 +6628,7 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
   }
   const dataLossCheck = checkForDataLoss(diff);
   if (dataLossCheck.warnings.length > 0) {
-    logger3.warn("[RuntimeMigrator] Schema changes may cause data loss:");
-    for (const warning of dataLossCheck.warnings) {
-      logger3.warn(`  - ${warning}`);
-    }
+    logger3.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
   }
   const schemasToCreate = new Set;
   for (const tableName of diff.tables.created) {
@@ -7015,7 +7050,7 @@ class DatabaseIntrospector {
     this.db = db2;
   }
   async introspectSchema(schemaName = "public") {
-    logger5.info(`[DatabaseIntrospector] Starting introspection for schema: ${schemaName}`);
+    logger5.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
     const tables = {};
     const schemas = {};
     const enums = {};
@@ -7023,7 +7058,7 @@ class DatabaseIntrospector {
     for (const tableInfo of allTables) {
       const tableName = tableInfo.table_name;
       const tableSchema = tableInfo.table_schema || "public";
-      logger5.debug(`[DatabaseIntrospector] Introspecting table: ${tableSchema}.${tableName}`);
+      logger5.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
       const columns2 = await this.getColumns(tableSchema, tableName);
       const columnsObject = {};
       const uniqueConstraintObject = {};
@@ -7040,15 +7075,17 @@ class DatabaseIntrospector {
       const indexesObject = {};
       for (const idx of indexes2) {
         if (!idx.is_primary && !idx.is_unique_constraint) {
-          indexesObject[idx.name] = {
-            name: idx.name,
-            columns: idx.columns.map((col) => ({
-              expression: col,
-              isExpression: false
-            })),
-            isUnique: idx.is_unique,
-            method: idx.method || "btree"
-          };
+          if (idx.columns && Array.isArray(idx.columns) && idx.columns.length > 0) {
+            indexesObject[idx.name] = {
+              name: idx.name,
+              columns: idx.columns.map((col) => ({
+                expression: col,
+                isExpression: false
+              })),
+              isUnique: idx.is_unique,
+              method: idx.method || "btree"
+            };
+          }
         }
       }
       const foreignKeys = await this.getForeignKeys(tableSchema, tableName);
@@ -7116,7 +7153,7 @@ class DatabaseIntrospector {
       }
       enums[key].values.push(enumInfo.value);
     }
-    logger5.info(`[DatabaseIntrospector] Introspection complete. Found ${Object.keys(tables).length} tables`);
+    logger5.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
     return {
       version: "7",
       dialect: "postgresql",
@@ -7378,7 +7415,7 @@ class RuntimeMigrator {
       }
     }
     for (const schemaName of schemasToCreate) {
-      logger6.debug(`[RuntimeMigrator] Ensuring schema '${schemaName}' exists`);
+      logger6.debug({ src: "plugin:sql", schemaName }, "Ensuring schema exists");
       await this.db.execute(sql.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
     }
   }
@@ -7389,10 +7426,10 @@ class RuntimeMigrator {
       const tableData = table3;
       const actualSchema = tableData.schema || "public";
       if (!isCorePLugin && actualSchema === "public") {
-        logger6.warn(`[RuntimeMigrator] WARNING: Plugin '${pluginName}' table '${tableData.name}' is using public schema. ` + `Consider using pgSchema('${expectedSchema}').table(...) for better isolation.`);
+        logger6.warn({ src: "plugin:sql", pluginName, tableName: tableData.name, expectedSchema }, "Plugin table is using public schema - consider using pgSchema for better isolation");
       }
       if (isCorePLugin && actualSchema !== "public") {
-        logger6.warn(`[RuntimeMigrator] WARNING: Core plugin '@elizaos/plugin-sql' table '${tableData.name}' is using schema '${actualSchema}'. ` + `Core tables should use public schema.`);
+        logger6.warn({ src: "plugin:sql", pluginName: "@elizaos/plugin-sql", tableName: tableData.name, actualSchema }, "Core plugin table should use public schema");
       }
     }
   }
@@ -7603,13 +7640,13 @@ class RuntimeMigrator {
         }
       }
     }
-    logger6.debug(`[RuntimeMigrator] Connection string did not match any PostgreSQL patterns: ${url.substring(0, 50)}...`);
+    logger6.debug({ src: "plugin:sql", urlPreview: url.substring(0, 50) }, "Connection string did not match any PostgreSQL patterns");
     return false;
   }
   async initialize() {
-    logger6.info("[RuntimeMigrator] Initializing migration system...");
+    logger6.info({ src: "plugin:sql" }, "Initializing migration system");
     await this.migrationTracker.ensureTables();
-    logger6.info("[RuntimeMigrator] Migration system initialized");
+    logger6.info({ src: "plugin:sql" }, "Migration system initialized");
   }
   async migrate(pluginName, schema2, options = {}) {
     const lockId = this.getAdvisoryLockId(pluginName);
@@ -7618,46 +7655,46 @@ class RuntimeMigrator {
     }
     let lockAcquired = false;
     try {
-      logger6.info(`[RuntimeMigrator] Starting migration for plugin: ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName }, "Starting migration for plugin");
       await this.initialize();
       const postgresUrl = process.env.POSTGRES_URL || process.env.DATABASE_URL || "";
       const isRealPostgres = this.isRealPostgresDatabase(postgresUrl);
       if (isRealPostgres) {
         try {
-          logger6.debug(`[RuntimeMigrator] Using PostgreSQL advisory locks for ${pluginName}`);
+          logger6.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
           const lockResult = await this.db.execute(sql`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
           lockAcquired = lockResult.rows[0]?.acquired === true;
           if (!lockAcquired) {
-            logger6.info(`[RuntimeMigrator] Migration already in progress for ${pluginName}, waiting for lock...`);
+            logger6.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
             await this.db.execute(sql`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
             lockAcquired = true;
-            logger6.info(`[RuntimeMigrator] Lock acquired for ${pluginName}`);
+            logger6.info({ src: "plugin:sql", pluginName }, "Lock acquired");
           } else {
-            logger6.debug(`[RuntimeMigrator] Advisory lock acquired for ${pluginName} (lock ID: ${lockIdStr})`);
+            logger6.debug({ src: "plugin:sql", pluginName, lockId: lockIdStr }, "Advisory lock acquired");
           }
         } catch (lockError) {
-          logger6.warn(`[RuntimeMigrator] Failed to acquire advisory lock, continuing without lock: ${lockError}`);
+          logger6.warn({ src: "plugin:sql", pluginName, error: lockError instanceof Error ? lockError.message : String(lockError) }, "Failed to acquire advisory lock, continuing without lock");
           lockAcquired = false;
         }
       } else {
-        logger6.debug(`[RuntimeMigrator] Development database detected (PGLite or non-PostgreSQL), skipping advisory locks`);
+        logger6.debug({ src: "plugin:sql" }, "Development database detected, skipping advisory locks");
       }
-      await this.extensionManager.installRequiredExtensions(["vector", "fuzzystrmatch"]);
+      await this.extensionManager.installRequiredExtensions(["vector", "fuzzystrmatch", "pgcrypto"]);
       const currentSnapshot = await generateSnapshot(schema2);
       await this.ensureSchemasExist(currentSnapshot);
       this.validateSchemaUsage(pluginName, currentSnapshot);
       const currentHash = hashSnapshot(currentSnapshot);
       const lastMigration = await this.migrationTracker.getLastMigration(pluginName);
       if (lastMigration && lastMigration.hash === currentHash) {
-        logger6.info(`[RuntimeMigrator] No changes detected for ${pluginName}, skipping migration (hash: ${currentHash})`);
+        logger6.info({ src: "plugin:sql", pluginName, hash: currentHash }, "No changes detected, skipping migration");
         return;
       }
       let previousSnapshot = await this.snapshotStorage.getLatestSnapshot(pluginName);
       if (!previousSnapshot && Object.keys(currentSnapshot.tables).length > 0) {
         const hasExistingTables = await this.introspector.hasExistingTables(pluginName);
         if (hasExistingTables) {
-          logger6.info(`[RuntimeMigrator] No snapshot found for ${pluginName} but tables exist in database. Introspecting...`);
+          logger6.info({ src: "plugin:sql", pluginName }, "No snapshot found but tables exist in database, introspecting");
           const schemaName = this.getExpectedSchemaName(pluginName);
           const introspectedSnapshot = await this.introspector.introspectSchema(schemaName);
           if (Object.keys(introspectedSnapshot.tables).length > 0) {
@@ -7665,15 +7702,15 @@ class RuntimeMigrator {
             await this.journalStorage.updateJournal(pluginName, 0, `introspected_${Date.now()}`, true);
             const introspectedHash = hashSnapshot(introspectedSnapshot);
             await this.migrationTracker.recordMigration(pluginName, introspectedHash, Date.now());
-            logger6.info(`[RuntimeMigrator] Created initial snapshot from existing database for ${pluginName}`);
+            logger6.info({ src: "plugin:sql", pluginName }, "Created initial snapshot from existing database");
             previousSnapshot = introspectedSnapshot;
           }
         }
       }
       if (!hasChanges(previousSnapshot, currentSnapshot)) {
-        logger6.info(`[RuntimeMigrator] No schema changes for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No schema changes");
         if (!previousSnapshot && Object.keys(currentSnapshot.tables).length === 0) {
-          logger6.info(`[RuntimeMigrator] Recording empty schema for ${pluginName}`);
+          logger6.info({ src: "plugin:sql", pluginName }, "Recording empty schema");
           await this.migrationTracker.recordMigration(pluginName, currentHash, Date.now());
           const idx = await this.journalStorage.getNextIdx(pluginName);
           const tag = this.generateMigrationTag(idx, pluginName);
@@ -7684,7 +7721,7 @@ class RuntimeMigrator {
       }
       const diff = await calculateDiff(previousSnapshot, currentSnapshot);
       if (!hasDiffChanges(diff)) {
-        logger6.info(`[RuntimeMigrator] No actionable changes for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No actionable changes");
         return;
       }
       const dataLossCheck = checkForDataLoss(diff);
@@ -7692,55 +7729,34 @@ class RuntimeMigrator {
         const isProduction = false;
         const allowDestructive = options.force || options.allowDataLoss || process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true";
         if (!allowDestructive) {
-          logger6.error("[RuntimeMigrator] Destructive migration blocked");
-          logger6.error(`[RuntimeMigrator] Plugin: ${pluginName}`);
-          logger6.error(`[RuntimeMigrator] Environment: ${isProduction ? "PRODUCTION" : "DEVELOPMENT"}`);
-          logger6.error("[RuntimeMigrator] Destructive operations detected:");
-          for (const warning of dataLossCheck.warnings) {
-            logger6.error(`[RuntimeMigrator]   - ${warning}`);
-          }
-          logger6.error("[RuntimeMigrator] To proceed with destructive migrations:");
-          logger6.error("[RuntimeMigrator]   1. Set environment variable: export ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true");
-          logger6.error("[RuntimeMigrator]   2. Or use option: migrate(plugin, schema, { force: true })");
-          if (isProduction) {
-            logger6.error("[RuntimeMigrator]   3. For production, consider using drizzle-kit for manual migration");
-          }
+          logger6.error({ src: "plugin:sql", pluginName, environment: isProduction ? "PRODUCTION" : "DEVELOPMENT", warnings: dataLossCheck.warnings }, "Destructive migration blocked - set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use force option");
           const errorMessage = isProduction ? `Destructive migration blocked in production for ${pluginName}. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use drizzle-kit.` : `Destructive migration blocked for ${pluginName}. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true to proceed.`;
           throw new Error(errorMessage);
         }
         if (dataLossCheck.requiresConfirmation) {
-          logger6.warn("[RuntimeMigrator] Proceeding with destructive migration");
-          logger6.warn(`[RuntimeMigrator] Plugin: ${pluginName}`);
-          logger6.warn("[RuntimeMigrator] The following operations will be performed:");
-          for (const warning of dataLossCheck.warnings) {
-            logger6.warn(`[RuntimeMigrator]   ⚠️ ${warning}`);
-          }
+          logger6.warn({ src: "plugin:sql", pluginName, warnings: dataLossCheck.warnings }, "Proceeding with destructive migration");
         }
       }
       const sqlStatements = await generateMigrationSQL(previousSnapshot, currentSnapshot, diff);
       if (sqlStatements.length === 0) {
-        logger6.info(`[RuntimeMigrator] No SQL statements to execute for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No SQL statements to execute");
         return;
       }
-      logger6.info(`[RuntimeMigrator] Executing ${sqlStatements.length} SQL statements for ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName, statementCount: sqlStatements.length }, "Executing SQL statements");
       if (options.verbose) {
         sqlStatements.forEach((stmt, i) => {
-          logger6.debug(`[RuntimeMigrator] Statement ${i + 1}: ${stmt}`);
+          logger6.debug({ src: "plugin:sql", statementIndex: i + 1, statement: stmt }, "SQL statement");
         });
       }
       if (options.dryRun) {
-        logger6.info("[RuntimeMigrator] DRY RUN mode - not executing statements");
-        logger6.info("[RuntimeMigrator] Would execute:");
-        sqlStatements.forEach((stmt, i) => {
-          logger6.info(`  ${i + 1}. ${stmt}`);
-        });
+        logger6.info({ src: "plugin:sql", pluginName, statements: sqlStatements }, "DRY RUN mode - not executing statements");
         return;
       }
       await this.executeMigration(pluginName, currentSnapshot, currentHash, sqlStatements);
-      logger6.info(`[RuntimeMigrator] Migration completed successfully for ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName }, "Migration completed successfully");
       return;
     } catch (error) {
-      logger6.error(`[RuntimeMigrator] Migration failed for ${pluginName}:`, JSON.stringify(error));
+      logger6.error({ src: "plugin:sql", pluginName, error: error instanceof Error ? error.message : String(error) }, "Migration failed");
       throw error;
     } finally {
       const postgresUrl = process.env.POSTGRES_URL || process.env.DATABASE_URL || "";
@@ -7749,9 +7765,9 @@ class RuntimeMigrator {
         try {
           const lockIdStr = lockId.toString();
           await this.db.execute(sql`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
-          logger6.debug(`[RuntimeMigrator] Advisory lock released for ${pluginName}`);
+          logger6.debug({ src: "plugin:sql", pluginName }, "Advisory lock released");
         } catch (unlockError) {
-          logger6.warn(`[RuntimeMigrator] Failed to release advisory lock for ${pluginName}:`, JSON.stringify(unlockError));
+          logger6.warn({ src: "plugin:sql", pluginName, error: unlockError instanceof Error ? unlockError.message : String(unlockError) }, "Failed to release advisory lock");
         }
       }
     }
@@ -7762,7 +7778,7 @@ class RuntimeMigrator {
       await this.db.execute(sql`BEGIN`);
       transactionStarted = true;
       for (const stmt of sqlStatements) {
-        logger6.debug(`[RuntimeMigrator] Executing: ${stmt}`);
+        logger6.debug({ src: "plugin:sql", statement: stmt }, "Executing SQL statement");
         await this.db.execute(sql.raw(stmt));
       }
       const idx = await this.journalStorage.getNextIdx(pluginName);
@@ -7771,14 +7787,14 @@ class RuntimeMigrator {
       await this.journalStorage.updateJournal(pluginName, idx, tag, true);
       await this.snapshotStorage.saveSnapshot(pluginName, idx, snapshot);
       await this.db.execute(sql`COMMIT`);
-      logger6.info(`[RuntimeMigrator] Recorded migration ${tag} for ${pluginName}`);
+      logger6.info({ src: "plugin:sql", pluginName, tag }, "Recorded migration");
     } catch (error) {
       if (transactionStarted) {
         try {
           await this.db.execute(sql`ROLLBACK`);
-          logger6.error("[RuntimeMigrator] Migration failed, rolled back:", JSON.stringify(error));
+          logger6.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Migration failed, rolled back");
         } catch (rollbackError) {
-          logger6.error("[RuntimeMigrator] Failed to rollback transaction:", JSON.stringify(rollbackError));
+          logger6.error({ src: "plugin:sql", error: rollbackError instanceof Error ? rollbackError.message : String(rollbackError) }, "Failed to rollback transaction");
         }
       }
       throw error;
@@ -7801,31 +7817,31 @@ class RuntimeMigrator {
     };
   }
   async reset(pluginName) {
-    logger6.warn(`[RuntimeMigrator] Resetting migrations for ${pluginName}`);
+    logger6.warn({ src: "plugin:sql", pluginName }, "Resetting migrations");
     await this.db.execute(sql`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
     await this.db.execute(sql`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
     await this.db.execute(sql`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
-    logger6.warn(`[RuntimeMigrator] Reset complete for ${pluginName}`);
+    logger6.warn({ src: "plugin:sql", pluginName }, "Reset complete");
   }
   async checkMigration(pluginName, schema2) {
     try {
-      logger6.info(`[RuntimeMigrator] Checking migration for ${pluginName}...`);
+      logger6.info({ src: "plugin:sql", pluginName }, "Checking migration");
       const currentSnapshot = await generateSnapshot(schema2);
       const previousSnapshot = await this.snapshotStorage.getLatestSnapshot(pluginName);
       if (!hasChanges(previousSnapshot, currentSnapshot)) {
-        logger6.info(`[RuntimeMigrator] No changes detected for ${pluginName}`);
+        logger6.info({ src: "plugin:sql", pluginName }, "No changes detected");
         return null;
       }
       const diff = await calculateDiff(previousSnapshot, currentSnapshot);
       const dataLossCheck = checkForDataLoss(diff);
       if (dataLossCheck.hasDataLoss) {
-        logger6.warn(`[RuntimeMigrator] Migration for ${pluginName} would cause data loss`);
+        logger6.warn({ src: "plugin:sql", pluginName }, "Migration would cause data loss");
       } else {
-        logger6.info(`[RuntimeMigrator] Migration for ${pluginName} is safe (no data loss)`);
+        logger6.info({ src: "plugin:sql", pluginName }, "Migration is safe (no data loss)");
       }
       return dataLossCheck;
     } catch (error) {
-      logger6.error(`[RuntimeMigrator] Failed to check migration for ${pluginName}:`, JSON.stringify(error));
+      logger6.error({ src: "plugin:sql", pluginName, error: error instanceof Error ? error.message : String(error) }, "Failed to check migration");
       throw error;
     }
   }
@@ -7847,12 +7863,810 @@ var init_runtime_migrator2 = __esm(() => {
   init_runtime_migrator();
 });
 
+// src/migrations.ts
+import { logger as logger7 } from "@elizaos/core";
+async function migrateToEntityRLS(adapter) {
+  const db2 = adapter.db;
+  try {
+    await db2.execute(sql`SELECT 1 FROM pg_tables LIMIT 1`);
+  } catch {
+    logger7.debug("[Migration] ⊘ Not PostgreSQL, skipping PostgreSQL-specific migrations");
+    return;
+  }
+  logger7.info("[Migration] Starting develop → feat/entity-rls migration...");
+  try {
+    logger7.debug("[Migration] → Clearing RuntimeMigrator snapshot cache...");
+    try {
+      await db2.execute(sql`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
+      logger7.debug("[Migration] ✓ Snapshot cache cleared");
+    } catch (error) {
+      logger7.debug("[Migration] ⊘ No snapshot cache to clear (migrations schema not yet created)");
+    }
+    logger7.debug("[Migration] → Disabling Row Level Security on all tables...");
+    try {
+      const tablesResult = await db2.execute(sql`
+        SELECT tablename
+        FROM pg_tables
+        WHERE schemaname = 'public'
+        ORDER BY tablename
+      `);
+      for (const row of tablesResult.rows || []) {
+        const tableName = row.tablename;
+        try {
+          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+          logger7.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
+        } catch (error) {
+          logger7.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
+        }
+      }
+    } catch (error) {
+      logger7.debug("[Migration] ⊘ Could not disable RLS (may not have permissions)");
+    }
+    logger7.debug("[Migration] → Handling server_id → message_server_id migrations...");
+    const tablesToMigrate = ["channels", "worlds", "rooms"];
+    for (const tableName of tablesToMigrate) {
+      try {
+        const columnsResult = await db2.execute(sql`
+          SELECT column_name, data_type, is_nullable
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name = ${tableName}
+            AND column_name IN ('server_id', 'message_server_id')
+          ORDER BY column_name
+        `);
+        const columns2 = columnsResult.rows || [];
+        const serverId = columns2.find((c) => c.column_name === "server_id");
+        const messageServerId = columns2.find((c) => c.column_name === "message_server_id");
+        if (serverId && !messageServerId) {
+          logger7.debug(`[Migration] → Renaming ${tableName}.server_id to message_server_id...`);
+          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "server_id" TO "message_server_id"`));
+          logger7.debug(`[Migration] ✓ Renamed ${tableName}.server_id → message_server_id`);
+          if (serverId.data_type === "text") {
+            try {
+              logger7.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
+              await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+              logger7.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
+              logger7.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid...`);
+              await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" TYPE uuid USING "message_server_id"::uuid`));
+              logger7.debug(`[Migration] ✓ Converted ${tableName}.message_server_id to uuid`);
+            } catch (convertError) {
+              logger7.warn(`[Migration] ⚠️ Could not convert ${tableName}.message_server_id to uuid - data may not be valid UUIDs`);
+              logger7.debug(`[Migration] → Setting invalid UUIDs to NULL in ${tableName}.message_server_id...`);
+              await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" TYPE uuid USING CASE WHEN "message_server_id" ~ '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$' THEN "message_server_id"::uuid ELSE NULL END`));
+            }
+          }
+          if (tableName === "channels") {
+            const nullCountResult = await db2.execute(sql.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+            const nullCount = nullCountResult.rows?.[0]?.count;
+            if (nullCount && parseInt(nullCount) > 0) {
+              logger7.warn(`[Migration] ⚠️ ${tableName} has ${nullCount} rows with NULL message_server_id - these will be deleted`);
+              await db2.execute(sql.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+              logger7.debug(`[Migration] ✓ Deleted ${nullCount} rows with NULL message_server_id from ${tableName}`);
+            }
+            logger7.debug(`[Migration] → Making ${tableName}.message_server_id NOT NULL...`);
+            await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
+            logger7.debug(`[Migration] ✓ Set ${tableName}.message_server_id NOT NULL`);
+          }
+        } else if (serverId && messageServerId) {
+          logger7.debug(`[Migration] → ${tableName} has both columns, dropping server_id...`);
+          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DROP COLUMN "server_id" CASCADE`));
+          logger7.debug(`[Migration] ✓ Dropped ${tableName}.server_id (will be re-added by RuntimeMigrator for RLS)`);
+        } else if (!serverId && messageServerId) {
+          if (messageServerId.data_type === "text") {
+            logger7.debug(`[Migration] → ${tableName}.message_server_id exists but is TEXT, needs UUID conversion...`);
+            logger7.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
+            await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+            logger7.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
+            logger7.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid (generating UUIDs from text)...`);
+            await db2.execute(sql.raw(`
+              ALTER TABLE "${tableName}"
+              ALTER COLUMN "message_server_id" TYPE uuid
+              USING CASE
+                WHEN "message_server_id" ~ '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'
+                THEN "message_server_id"::uuid
+                ELSE md5("message_server_id")::uuid
+              END
+            `));
+            logger7.debug(`[Migration] ✓ Converted ${tableName}.message_server_id to uuid`);
+          } else {
+            logger7.debug(`[Migration] ⊘ ${tableName}.message_server_id already UUID, skipping`);
+          }
+        } else {
+          logger7.debug(`[Migration] ⊘ ${tableName} already migrated, skipping`);
+        }
+      } catch (error) {
+        logger7.warn(`[Migration] ⚠️ Error migrating ${tableName}.server_id: ${error}`);
+      }
+    }
+    logger7.debug("[Migration] → Dropping all remaining RLS-managed server_id columns...");
+    try {
+      const serverIdColumnsResult = await db2.execute(sql`
+        SELECT table_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND column_name = 'server_id'
+          AND table_name NOT IN (
+            'servers',              -- server_id is the primary key
+            'agents',               -- server_id is in the schema (for RLS)
+            'channels',             -- already handled above
+            'worlds',               -- already handled above
+            'rooms',                -- already handled above
+            'server_agents',        -- server_id is part of composite key
+            'drizzle_migrations',
+            '__drizzle_migrations'
+          )
+        ORDER BY table_name
+      `);
+      const tablesToClean = serverIdColumnsResult.rows || [];
+      logger7.debug(`[Migration] → Found ${tablesToClean.length} tables with server_id columns`);
+      for (const row of tablesToClean) {
+        const tableName = row.table_name;
+        try {
+          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
+          logger7.debug(`[Migration] ✓ Dropped server_id from ${tableName}`);
+        } catch (error) {
+          logger7.debug(`[Migration] ⊘ Could not drop server_id from ${tableName}`);
+        }
+      }
+    } catch (error) {
+      logger7.debug("[Migration] ⊘ Could not drop server_id columns (may not have permissions)");
+    }
+    logger7.debug("[Migration] → Checking server_agents table rename...");
+    try {
+      const tablesResult = await db2.execute(sql`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name IN ('server_agents', 'message_server_agents')
+        ORDER BY table_name
+      `);
+      const tables = tablesResult.rows || [];
+      const hasServerAgents = tables.some((t) => t.table_name === "server_agents");
+      const hasMessageServerAgents = tables.some((t) => t.table_name === "message_server_agents");
+      if (hasServerAgents && !hasMessageServerAgents) {
+        logger7.debug("[Migration] → Renaming server_agents to message_server_agents...");
+        await db2.execute(sql.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
+        logger7.debug("[Migration] ✓ Renamed server_agents → message_server_agents");
+        logger7.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
+        await db2.execute(sql.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+        logger7.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
+      } else if (!hasServerAgents && !hasMessageServerAgents) {
+        logger7.debug("[Migration] ⊘ No server_agents table to migrate");
+      } else if (hasMessageServerAgents) {
+        logger7.debug("[Migration] → Checking message_server_agents columns...");
+        const columnsResult = await db2.execute(sql`
+          SELECT column_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name = 'message_server_agents'
+            AND column_name IN ('server_id', 'message_server_id')
+          ORDER BY column_name
+        `);
+        const columns2 = columnsResult.rows || [];
+        const hasServerId = columns2.some((c) => c.column_name === "server_id");
+        const hasMessageServerId = columns2.some((c) => c.column_name === "message_server_id");
+        if (hasServerId && !hasMessageServerId) {
+          logger7.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
+          await db2.execute(sql.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+          logger7.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
+        } else if (!hasServerId && !hasMessageServerId) {
+          logger7.debug("[Migration] → message_server_agents exists without required columns, truncating...");
+          await db2.execute(sql`TRUNCATE TABLE message_server_agents CASCADE`);
+          logger7.debug("[Migration] ✓ Truncated message_server_agents");
+        } else {
+          logger7.debug("[Migration] ⊘ message_server_agents already has correct schema");
+        }
+      }
+    } catch (error) {
+      logger7.debug("[Migration] ⊘ Could not check/migrate server_agents table");
+    }
+    logger7.debug("[Migration] → Checking channel_participants table...");
+    try {
+      const columnsResult = await db2.execute(sql`
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = 'channel_participants'
+          AND column_name IN ('user_id', 'entity_id')
+        ORDER BY column_name
+      `);
+      const columns2 = columnsResult.rows || [];
+      const hasUserId = columns2.some((c) => c.column_name === "user_id");
+      const hasEntityId = columns2.some((c) => c.column_name === "entity_id");
+      if (hasUserId && !hasEntityId) {
+        logger7.debug("[Migration] → Renaming channel_participants.user_id to entity_id...");
+        await db2.execute(sql.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
+        logger7.debug("[Migration] ✓ Renamed channel_participants.user_id → entity_id");
+      } else if (!hasUserId && !hasEntityId) {
+        logger7.debug("[Migration] → channel_participants exists without entity_id or user_id, truncating...");
+        await db2.execute(sql`TRUNCATE TABLE channel_participants CASCADE`);
+        logger7.debug("[Migration] ✓ Truncated channel_participants");
+      } else {
+        logger7.debug("[Migration] ⊘ channel_participants already has entity_id column");
+      }
+    } catch (error) {
+      logger7.debug("[Migration] ⊘ Could not check/migrate channel_participants");
+    }
+    logger7.debug("[Migration] → Discovering and dropping all regular indexes...");
+    try {
+      const indexesResult = await db2.execute(sql`
+        SELECT i.relname AS index_name
+        FROM pg_index idx
+        JOIN pg_class i ON i.oid = idx.indexrelid
+        JOIN pg_class c ON c.oid = idx.indrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        LEFT JOIN pg_constraint con ON con.conindid = idx.indexrelid
+        WHERE n.nspname = 'public'
+          AND NOT idx.indisprimary  -- Not a primary key
+          AND con.contype IS NULL   -- Not a constraint (unique, etc)
+        ORDER BY i.relname
+      `);
+      const indexesToDrop = indexesResult.rows || [];
+      logger7.debug(`[Migration] → Found ${indexesToDrop.length} indexes to drop`);
+      for (const row of indexesToDrop) {
+        const indexName = row.index_name;
+        try {
+          await db2.execute(sql.raw(`DROP INDEX IF EXISTS "${indexName}"`));
+          logger7.debug(`[Migration] ✓ Dropped index ${indexName}`);
+        } catch (error) {
+          logger7.debug(`[Migration] ⊘ Could not drop index ${indexName}`);
+        }
+      }
+    } catch (error) {
+      logger7.debug("[Migration] ⊘ Could not drop indexes (may not have permissions)");
+    }
+    logger7.info("[Migration] ✓ Migration complete - develop to feat/entity-rls migration finished");
+  } catch (error) {
+    logger7.error("[Migration] Migration failed:", String(error));
+    throw error;
+  }
+}
+var init_migrations = __esm(() => {
+  init_drizzle_orm();
+});
+
+// src/rls.ts
+import { logger as logger8, validateUuid } from "@elizaos/core";
+async function installRLSFunctions(adapter) {
+  const db2 = adapter.db;
+  await db2.execute(sql`
+    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 db2.execute(sql`
+    CREATE OR REPLACE FUNCTION current_server_id() RETURNS UUID AS $$
+    DECLARE
+      app_name TEXT;
+    BEGIN
+      app_name := NULLIF(current_setting('application_name', TRUE), '');
+
+      -- Return NULL if application_name is not set or not a valid UUID
+      -- This allows admin queries to work without RLS restrictions
+      BEGIN
+        RETURN app_name::UUID;
+      EXCEPTION WHEN OTHERS THEN
+        RETURN NULL;
+      END;
+    END;
+    $$ LANGUAGE plpgsql STABLE;
+  `);
+  await db2.execute(sql`
+    CREATE OR REPLACE FUNCTION add_server_isolation(
+      schema_name text,
+      table_name text
+    ) RETURNS void AS $$
+    DECLARE
+      full_table_name text;
+      column_exists boolean;
+      orphaned_count bigint;
+    BEGIN
+      full_table_name := schema_name || '.' || table_name;
+
+      -- Check if server_id column already exists
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_server_isolation.table_name
+          AND information_schema.columns.column_name = 'server_id'
+      ) INTO column_exists;
+
+      -- Add server_id column if missing (DEFAULT populates it automatically for new rows)
+      IF NOT column_exists THEN
+        EXECUTE format('ALTER TABLE %I.%I ADD COLUMN server_id UUID DEFAULT current_server_id()', schema_name, table_name);
+
+        -- Backfill existing rows with current server_id
+        -- This ensures all existing data belongs to the server instance that is enabling RLS
+        EXECUTE format('UPDATE %I.%I SET server_id = current_server_id() WHERE server_id IS NULL', schema_name, table_name);
+      ELSE
+        -- Column already exists (RLS was previously enabled then disabled)
+        -- Restore the DEFAULT clause (may have been removed during uninstallRLS)
+        EXECUTE format('ALTER TABLE %I.%I ALTER COLUMN server_id SET DEFAULT current_server_id()', schema_name, table_name);
+
+        -- Only backfill NULL server_id rows, do NOT steal data from other servers
+        EXECUTE format('SELECT COUNT(*) FROM %I.%I WHERE server_id IS NULL', schema_name, table_name) INTO orphaned_count;
+
+        IF orphaned_count > 0 THEN
+          RAISE NOTICE 'Backfilling % rows with NULL server_id in %.%', orphaned_count, schema_name, table_name;
+          EXECUTE format('UPDATE %I.%I SET server_id = current_server_id() WHERE server_id IS NULL', schema_name, table_name);
+        END IF;
+      END IF;
+
+      -- Create index for efficient server_id filtering
+      EXECUTE format('CREATE INDEX IF NOT EXISTS idx_%I_server_id ON %I.%I(server_id)', table_name, schema_name, table_name);
+
+      -- Enable RLS on the table
+      EXECUTE format('ALTER TABLE %I.%I ENABLE ROW LEVEL SECURITY', schema_name, table_name);
+
+      -- FORCE RLS even for table owners (critical for security)
+      EXECUTE format('ALTER TABLE %I.%I FORCE ROW LEVEL SECURITY', schema_name, table_name);
+
+      -- Drop existing policy if present
+      EXECUTE format('DROP POLICY IF EXISTS server_isolation_policy ON %I.%I', schema_name, table_name);
+
+      -- Create isolation policy: users can only see/modify rows where server_id matches current server instance
+      -- No NULL clause - all rows must have a valid server_id (backfilled during column addition)
+      EXECUTE format('
+        CREATE POLICY server_isolation_policy ON %I.%I
+        USING (server_id = current_server_id())
+        WITH CHECK (server_id = current_server_id())
+      ', schema_name, table_name);
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  await db2.execute(sql`
+    CREATE OR REPLACE FUNCTION apply_rls_to_all_tables() RETURNS void AS $$
+    DECLARE
+      tbl record;
+    BEGIN
+      FOR tbl IN
+        SELECT schemaname, tablename
+        FROM pg_tables
+        WHERE schemaname = 'public'
+          AND tablename NOT IN (
+            'servers',
+            'drizzle_migrations',
+            '__drizzle_migrations'
+          )
+      LOOP
+        BEGIN
+          PERFORM add_server_isolation(tbl.schemaname, tbl.tablename);
+        EXCEPTION WHEN OTHERS THEN
+          RAISE WARNING 'Failed to apply RLS to %.%: %', tbl.schemaname, tbl.tablename, SQLERRM;
+        END;
+      END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  logger8.info({ src: "plugin:sql" }, "RLS PostgreSQL functions installed");
+  await installEntityRLS(adapter);
+}
+async function getOrCreateRlsServer(adapter, serverId) {
+  const db2 = adapter.db;
+  await db2.insert(serverTable).values({
+    id: serverId
+  }).onConflictDoNothing();
+  logger8.info({ src: "plugin:sql", serverId: serverId.slice(0, 8) }, "RLS server registered");
+  return serverId;
+}
+async function setServerContext(adapter, serverId) {
+  if (!validateUuid(serverId)) {
+    throw new Error(`Invalid server ID format: ${serverId}. Must be a valid UUID.`);
+  }
+  const db2 = adapter.db;
+  const servers = await db2.select().from(serverTable).where(eq(serverTable.id, serverId));
+  if (servers.length === 0) {
+    throw new Error(`Server ${serverId} does not exist`);
+  }
+  logger8.info({ src: "plugin:sql", serverId: serverId.slice(0, 8) }, "RLS context configured");
+}
+async function assignAgentToServer(adapter, agentId, serverId) {
+  if (!agentId || !serverId) {
+    logger8.warn(`[Data Isolation] Cannot assign agent to server: invalid agentId (${agentId}) or serverId (${serverId})`);
+    return;
+  }
+  const db2 = adapter.db;
+  const agents = await db2.select().from(agentTable).where(eq(agentTable.id, agentId));
+  if (agents.length > 0) {
+    const agent = agents[0];
+    const currentServerId = agent.server_id;
+    if (currentServerId === serverId) {
+      logger8.debug({ src: "plugin:sql", agentName: agent.name }, "Agent already assigned to correct server");
+    } else {
+      await db2.update(agentTable).set({ server_id: serverId }).where(eq(agentTable.id, agentId));
+      if (currentServerId === null) {
+        logger8.info({ src: "plugin:sql", agentName: agent.name }, "Agent assigned to server");
+      } else {
+        logger8.warn({ src: "plugin:sql", agentName: agent.name }, "Agent server changed");
+      }
+    }
+  } else {
+    logger8.debug({ src: "plugin:sql", agentId }, "Agent does not exist yet");
+  }
+}
+async function applyRLSToNewTables(adapter) {
+  const db2 = adapter.db;
+  try {
+    await db2.execute(sql`SELECT apply_rls_to_all_tables()`);
+    logger8.info({ src: "plugin:sql" }, "RLS applied to all tables");
+  } catch (error) {
+    logger8.warn({ src: "plugin:sql", error: String(error) }, "Failed to apply RLS to some tables");
+  }
+}
+async function uninstallRLS(adapter) {
+  const db2 = adapter.db;
+  try {
+    const checkResult = await db2.execute(sql`
+      SELECT EXISTS (
+        SELECT FROM pg_tables
+        WHERE schemaname = 'public' AND tablename = 'servers'
+      ) as rls_enabled
+    `);
+    const rlsEnabled = checkResult.rows?.[0]?.rls_enabled;
+    if (!rlsEnabled) {
+      logger8.debug({ src: "plugin:sql" }, "RLS not installed, skipping cleanup");
+      return;
+    }
+    logger8.info({ src: "plugin:sql" }, "Disabling RLS globally (keeping server_id columns for schema compatibility)...");
+    try {
+      await uninstallEntityRLS(adapter);
+    } catch (entityRlsError) {
+      logger8.debug({ src: "plugin:sql" }, "Entity RLS cleanup skipped (not installed or already cleaned)");
+    }
+    await db2.execute(sql`
+      CREATE OR REPLACE FUNCTION _temp_disable_rls_on_table(
+        p_schema_name text,
+        p_table_name text
+      ) RETURNS void AS $$
+      DECLARE
+        policy_rec record;
+      BEGIN
+        -- Drop all policies on this table
+        FOR policy_rec IN
+          SELECT policyname
+          FROM pg_policies
+          WHERE schemaname = p_schema_name AND tablename = p_table_name
+        LOOP
+          EXECUTE format('DROP POLICY IF EXISTS %I ON %I.%I',
+            policy_rec.policyname, p_schema_name, p_table_name);
+        END LOOP;
+
+        -- Disable RLS
+        EXECUTE format('ALTER TABLE %I.%I NO FORCE ROW LEVEL SECURITY', p_schema_name, p_table_name);
+        EXECUTE format('ALTER TABLE %I.%I DISABLE ROW LEVEL SECURITY', p_schema_name, p_table_name);
+      END;
+      $$ LANGUAGE plpgsql;
+    `);
+    const tablesResult = await db2.execute(sql`
+      SELECT schemaname, tablename
+      FROM pg_tables
+      WHERE schemaname = 'public'
+        AND tablename NOT IN ('drizzle_migrations', '__drizzle_migrations')
+    `);
+    for (const row of tablesResult.rows || []) {
+      const schemaName = row.schemaname;
+      const tableName = row.tablename;
+      try {
+        await db2.execute(sql`SELECT _temp_disable_rls_on_table(${schemaName}, ${tableName})`);
+        logger8.debug({ src: "plugin:sql", schemaName, tableName }, "Disabled RLS on table");
+      } catch (error) {
+        logger8.warn({ src: "plugin:sql", schemaName, tableName, error: String(error) }, "Failed to disable RLS on table");
+      }
+    }
+    await db2.execute(sql`DROP FUNCTION IF EXISTS _temp_disable_rls_on_table(text, text)`);
+    logger8.info({ src: "plugin:sql" }, "Keeping server_id values intact (prevents data theft on re-enable)");
+    logger8.info({ src: "plugin:sql" }, "Clearing servers table...");
+    await db2.execute(sql`TRUNCATE TABLE servers`);
+    await db2.execute(sql`DROP FUNCTION IF EXISTS apply_rls_to_all_tables() CASCADE`);
+    await db2.execute(sql`DROP FUNCTION IF EXISTS add_server_isolation(text, text) CASCADE`);
+    await db2.execute(sql`DROP FUNCTION IF EXISTS current_server_id() CASCADE`);
+    logger8.info({ src: "plugin:sql" }, "Dropped all RLS functions");
+    logger8.info({ src: "plugin:sql" }, "RLS disabled successfully (server_id columns preserved)");
+  } catch (error) {
+    logger8.error({ src: "plugin:sql", error: String(error) }, "Failed to disable RLS");
+    throw error;
+  }
+}
+async function installEntityRLS(adapter) {
+  const db2 = adapter.db;
+  logger8.info("[Entity RLS] Installing entity RLS functions and policies...");
+  await db2.execute(sql`
+    CREATE OR REPLACE FUNCTION current_entity_id()
+    RETURNS UUID AS $$
+    DECLARE
+      entity_id_text TEXT;
+    BEGIN
+      -- Read from transaction-local variable
+      entity_id_text := NULLIF(current_setting('app.entity_id', TRUE), '');
+
+      IF entity_id_text IS NULL OR entity_id_text = '' THEN
+        RETURN NULL;
+      END IF;
+
+      BEGIN
+        RETURN entity_id_text::UUID;
+      EXCEPTION WHEN OTHERS THEN
+        RETURN NULL;
+      END;
+    END;
+    $$ LANGUAGE plpgsql STABLE;
+  `);
+  logger8.info("[Entity RLS] Created current_entity_id() function");
+  await db2.execute(sql`
+    CREATE OR REPLACE FUNCTION add_entity_isolation(
+      schema_name text,
+      table_name text,
+      require_entity boolean DEFAULT false
+    ) RETURNS void AS $$
+    DECLARE
+      full_table_name text;
+      has_entity_id boolean;
+      has_author_id boolean;
+      has_channel_id boolean;
+      has_room_id boolean;
+      entity_column_name text;
+      room_column_name text;
+    BEGIN
+      full_table_name := schema_name || '.' || table_name;
+
+      -- Check which columns exist (using camelCase as per schema definition)
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_entity_isolation.table_name
+          AND information_schema.columns.column_name = 'entityId'
+      ) INTO has_entity_id;
+
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_entity_isolation.table_name
+          AND information_schema.columns.column_name = 'authorId'
+      ) INTO has_author_id;
+
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_entity_isolation.table_name
+          AND information_schema.columns.column_name = 'roomId'
+      ) INTO has_room_id;
+
+      -- Skip if no entity-related columns
+      IF NOT (has_entity_id OR has_author_id OR has_room_id) THEN
+        RAISE NOTICE '[Entity RLS] Skipping %.%: no entity columns found', schema_name, table_name;
+        RETURN;
+      END IF;
+
+      -- Determine which column to use for entity filtering
+      -- Priority: roomId (shared access via participants) > entityId/authorId (direct access)
+      --
+      -- SPECIAL CASE: participants table must use direct entityId to avoid infinite recursion
+      IF table_name = 'participants' AND has_entity_id THEN
+        entity_column_name := 'entityId';
+        room_column_name := NULL;
+      ELSIF has_room_id THEN
+        room_column_name := 'roomId';
+        entity_column_name := NULL;
+      ELSIF has_entity_id THEN
+        entity_column_name := 'entityId';
+        room_column_name := NULL;
+      ELSIF has_author_id THEN
+        entity_column_name := 'authorId';
+        room_column_name := NULL;
+      ELSE
+        entity_column_name := NULL;
+        room_column_name := NULL;
+      END IF;
+
+      -- Enable RLS on the table
+      EXECUTE format('ALTER TABLE %I.%I ENABLE ROW LEVEL SECURITY', schema_name, table_name);
+      EXECUTE format('ALTER TABLE %I.%I FORCE ROW LEVEL SECURITY', schema_name, table_name);
+
+      -- Drop existing entity policies if present
+      EXECUTE format('DROP POLICY IF EXISTS entity_isolation_policy ON %I.%I', schema_name, table_name);
+
+      -- CASE 1: Table has roomId or channelId (shared access via participants)
+      IF room_column_name IS NOT NULL THEN
+        -- Determine the corresponding column name in participants table
+        -- If the table has roomId, look for roomId in participants.roomId
+        -- participants table uses: entityId (for participant), roomId (for room)
+        -- RESTRICTIVE: Must pass BOTH server RLS AND entity RLS (combined with AND)
+
+        -- Build policy with or without NULL check based on require_entity parameter
+        IF require_entity THEN
+          -- STRICT MODE: Entity context is REQUIRED (blocks NULL entity_id)
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NOT NULL
+              AND %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+            WITH CHECK (
+              current_entity_id() IS NOT NULL
+              AND %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+          ', schema_name, table_name, room_column_name, room_column_name);
+          RAISE NOTICE '[Entity RLS] Applied STRICT RESTRICTIVE to %.% (via % → participants.roomId, entity REQUIRED)', schema_name, table_name, room_column_name;
+        ELSE
+          -- PERMISSIVE MODE: NULL entity_id allows system/admin access
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NULL
+              OR %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+            WITH CHECK (
+              current_entity_id() IS NULL
+              OR %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+          ', schema_name, table_name, room_column_name, room_column_name);
+          RAISE NOTICE '[Entity RLS] Applied PERMISSIVE RESTRICTIVE to %.% (via % → participants.roomId, NULL allowed)', schema_name, table_name, room_column_name;
+        END IF;
+
+      -- CASE 2: Table has direct entity_id or author_id column
+      ELSIF entity_column_name IS NOT NULL THEN
+        -- RESTRICTIVE: Must pass BOTH server RLS AND entity RLS (combined with AND)
+
+        IF require_entity THEN
+          -- STRICT MODE: Entity context is REQUIRED
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NOT NULL
+              AND %I = current_entity_id()
+            )
+            WITH CHECK (
+              current_entity_id() IS NOT NULL
+              AND %I = current_entity_id()
+            )
+          ', schema_name, table_name, entity_column_name, entity_column_name);
+          RAISE NOTICE '[Entity RLS] Applied STRICT RESTRICTIVE to %.% (direct column: %, entity REQUIRED)', schema_name, table_name, entity_column_name;
+        ELSE
+          -- PERMISSIVE MODE: NULL entity_id allows system/admin access
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NULL
+              OR %I = current_entity_id()
+            )
+            WITH CHECK (
+              current_entity_id() IS NULL
+              OR %I = current_entity_id()
+            )
+          ', schema_name, table_name, entity_column_name, entity_column_name);
+          RAISE NOTICE '[Entity RLS] Applied PERMISSIVE RESTRICTIVE to %.% (direct column: %, NULL allowed)', schema_name, table_name, entity_column_name;
+        END IF;
+      END IF;
+
+      -- Create indexes for efficient entity filtering
+      IF room_column_name IS NOT NULL THEN
+        EXECUTE format('CREATE INDEX IF NOT EXISTS idx_%I_room ON %I.%I(%I)',
+          table_name, schema_name, table_name, room_column_name);
+      END IF;
+
+      IF entity_column_name IS NOT NULL THEN
+        EXECUTE format('CREATE INDEX IF NOT EXISTS idx_%I_entity ON %I.%I(%I)',
+          table_name, schema_name, table_name, entity_column_name);
+      END IF;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  logger8.info("[Entity RLS] Created add_entity_isolation() function");
+  await db2.execute(sql`
+    CREATE OR REPLACE FUNCTION apply_entity_rls_to_all_tables() RETURNS void AS $$
+    DECLARE
+      tbl record;
+      require_entity_for_table boolean;
+    BEGIN
+      FOR tbl IN
+        SELECT schemaname, tablename
+        FROM pg_tables
+        WHERE schemaname = 'public'
+          AND tablename NOT IN (
+            'servers',              -- Server RLS table
+            'users',                -- Authentication table (no entity isolation needed)
+            'entity_mappings',      -- Mapping table (no entity isolation needed)
+            'drizzle_migrations',   -- Migration tracking
+            '__drizzle_migrations'  -- Migration tracking
+          )
+      LOOP
+        BEGIN
+          -- Apply STRICT mode (require_entity=true) to sensitive user-facing tables
+          -- These tables MUST have entity context set to access data
+          -- STRICT tables: memories, logs, components, tasks (user data requiring isolation)
+          -- NOTE: Excluded tables:
+          --   - 'participants': Adding participants is a privileged operation during initialization
+          IF tbl.tablename IN ('memories', 'logs', 'components', 'tasks') THEN
+            require_entity_for_table := true;
+          ELSE
+            -- PERMISSIVE mode (require_entity=false) for system/privileged tables
+            -- This includes: participants, rooms, channels, entities, etc.
+            require_entity_for_table := false;
+          END IF;
+
+          PERFORM add_entity_isolation(tbl.schemaname, tbl.tablename, require_entity_for_table);
+        EXCEPTION WHEN OTHERS THEN
+          RAISE WARNING '[Entity RLS] Failed to apply to %.%: %', tbl.schemaname, tbl.tablename, SQLERRM;
+        END;
+      END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  logger8.info("[Entity RLS] Created apply_entity_rls_to_all_tables() function");
+  logger8.info("[Entity RLS] Entity RLS functions installed successfully");
+}
+async function applyEntityRLSToAllTables(adapter) {
+  const db2 = adapter.db;
+  try {
+    await db2.execute(sql`SELECT apply_entity_rls_to_all_tables()`);
+    logger8.info("[Entity RLS] Applied entity RLS to all eligible tables");
+  } catch (error) {
+    logger8.warn("[Entity RLS] Failed to apply entity RLS to some tables:", String(error));
+  }
+}
+async function uninstallEntityRLS(adapter) {
+  const db2 = adapter.db;
+  logger8.info("[Entity RLS] Removing entity RLS policies and functions...");
+  try {
+    const tablesResult = await db2.execute(sql`
+      SELECT schemaname, tablename
+      FROM pg_tables
+      WHERE schemaname = 'public'
+        AND tablename NOT IN ('drizzle_migrations', '__drizzle_migrations')
+    `);
+    for (const row of tablesResult.rows || []) {
+      const schemaName = row.schemaname;
+      const tableName = row.tablename;
+      try {
+        await db2.execute(sql.raw(`DROP POLICY IF EXISTS entity_isolation_policy ON ${schemaName}.${tableName}`));
+        logger8.debug(`[Entity RLS] Dropped entity_isolation_policy from ${schemaName}.${tableName}`);
+      } catch (error) {
+        logger8.debug(`[Entity RLS] No entity policy on ${schemaName}.${tableName}`);
+      }
+    }
+    await db2.execute(sql`DROP FUNCTION IF EXISTS apply_entity_rls_to_all_tables() CASCADE`);
+    await db2.execute(sql`DROP FUNCTION IF EXISTS add_entity_isolation(text, text) CASCADE`);
+    await db2.execute(sql`DROP FUNCTION IF EXISTS current_entity_id() CASCADE`);
+    logger8.info("[Entity RLS] Entity RLS functions and policies removed successfully");
+  } catch (error) {
+    logger8.error("[Entity RLS] Failed to remove entity RLS:", String(error));
+    throw error;
+  }
+}
+var init_rls = __esm(() => {
+  init_drizzle_orm();
+  init_server();
+  init_agent();
+});
+
 // src/migration-service.ts
 var exports_migration_service = {};
 __export(exports_migration_service, {
   DatabaseMigrationService: () => DatabaseMigrationService
 });
-import { logger as logger7 } from "@elizaos/core";
+import { logger as logger9 } from "@elizaos/core";
 
 class DatabaseMigrationService {
   db = null;
@@ -7861,22 +8675,22 @@ class DatabaseMigrationService {
   constructor() {}
   async initializeWithDatabase(db2) {
     this.db = db2;
+    await migrateToEntityRLS({ db: db2 });
     this.migrator = new RuntimeMigrator(db2);
     await this.migrator.initialize();
-    logger7.info("DatabaseMigrationService initialized with database and runtime migrator");
+    logger9.info({ src: "plugin:sql" }, "DatabaseMigrationService initialized");
   }
   discoverAndRegisterPluginSchemas(plugins) {
     for (const plugin of plugins) {
       if (plugin.schema) {
         this.registeredSchemas.set(plugin.name, plugin.schema);
-        logger7.info(`Registered schema for plugin: ${plugin.name}`);
       }
     }
-    logger7.info(`Discovered ${this.registeredSchemas.size} plugin schemas out of ${plugins.length} plugins`);
+    logger9.info({ src: "plugin:sql", schemasDiscovered: this.registeredSchemas.size, totalPlugins: plugins.length }, "Plugin schemas discovered");
   }
   registerSchema(pluginName, schema2) {
     this.registeredSchemas.set(pluginName, schema2);
-    logger7.info(`Registered schema for plugin: ${pluginName}`);
+    logger9.debug({ src: "plugin:sql", pluginName }, "Schema registered");
   }
   async runAllPluginMigrations(options) {
     if (!this.db || !this.migrator) {
@@ -7888,12 +8702,7 @@ class DatabaseMigrationService {
       force: options?.force ?? false,
       dryRun: options?.dryRun ?? false
     };
-    logger7.info("[DatabaseMigrationService] Starting migrations");
-    logger7.info(`[DatabaseMigrationService] Environment: ${isProduction ? "PRODUCTION" : "DEVELOPMENT"}`);
-    logger7.info(`[DatabaseMigrationService] Plugins to migrate: ${this.registeredSchemas.size}`);
-    if (migrationOptions.dryRun) {
-      logger7.info("[DatabaseMigrationService] DRY RUN mode - no changes will be applied");
-    }
+    logger9.info({ src: "plugin:sql", environment: isProduction ? "PRODUCTION" : "DEVELOPMENT", pluginCount: this.registeredSchemas.size, dryRun: migrationOptions.dryRun }, "Starting migrations");
     let successCount = 0;
     let failureCount = 0;
     const errors2 = [];
@@ -7901,27 +8710,37 @@ class DatabaseMigrationService {
       try {
         await this.migrator.migrate(pluginName, schema2, migrationOptions);
         successCount++;
-        logger7.info(`[DatabaseMigrationService] ✅ Completed: ${pluginName}`);
+        logger9.info({ src: "plugin:sql", pluginName }, "Migration completed");
       } catch (error) {
         failureCount++;
         const errorMessage = error.message;
         errors2.push({ pluginName, error });
         if (errorMessage.includes("Destructive migration blocked")) {
-          logger7.error(`[DatabaseMigrationService] ❌ Blocked: ${pluginName} (destructive changes detected)`);
-          if (!migrationOptions.force && process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS !== "true") {
-            logger7.error("[DatabaseMigrationService] To allow destructive migrations:");
-            logger7.error("[DatabaseMigrationService]   - Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true");
-            logger7.error("[DatabaseMigrationService]   - Or pass { force: true } to this method");
-          }
+          logger9.error({ src: "plugin:sql", pluginName }, "Migration blocked - destructive changes detected. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use force option");
         } else {
-          logger7.error(`[DatabaseMigrationService] ❌ Failed: ${pluginName}`, JSON.stringify(error));
+          logger9.error({ src: "plugin:sql", pluginName, error: errorMessage }, "Migration failed");
         }
       }
     }
     if (failureCount === 0) {
-      logger7.info(`[DatabaseMigrationService] All ${successCount} migrations completed successfully`);
+      logger9.info({ src: "plugin:sql", successCount }, "All migrations completed successfully");
+      const dataIsolationEnabled = process.env.ENABLE_DATA_ISOLATION === "true";
+      if (dataIsolationEnabled) {
+        try {
+          logger9.info({ src: "plugin:sql" }, "Re-applying Row Level Security...");
+          await installRLSFunctions({ db: this.db });
+          await applyRLSToNewTables({ db: this.db });
+          await applyEntityRLSToAllTables({ db: this.db });
+          logger9.info({ src: "plugin:sql" }, "RLS re-applied successfully");
+        } catch (rlsError) {
+          const errorMsg = rlsError instanceof Error ? rlsError.message : String(rlsError);
+          logger9.warn({ src: "plugin:sql", error: errorMsg }, "Failed to re-apply RLS (this is OK if server_id columns are not yet in schemas)");
+        }
+      } else {
+        logger9.info({ src: "plugin:sql" }, "Skipping RLS re-application (ENABLE_DATA_ISOLATION is not true)");
+      }
     } else {
-      logger7.error(`[DatabaseMigrationService] Migrations failed: ${failureCount} failed, ${successCount} succeeded`);
+      logger9.error({ src: "plugin:sql", failureCount, successCount }, "Some migrations failed");
       const errorSummary = errors2.map((e) => `${e.pluginName}: ${e.error.message}`).join(`
   `);
       throw new Error(`${failureCount} migration(s) failed:
@@ -7934,13 +8753,16 @@ class DatabaseMigrationService {
 }
 var init_migration_service = __esm(() => {
   init_runtime_migrator2();
+  init_migrations();
+  init_rls();
 });
 
 // src/index.node.ts
-import { logger as logger13, stringToUuid } from "@elizaos/core";
+import { logger as logger14, stringToUuid } from "@elizaos/core";
+import { mkdirSync } from "node:fs";
 
 // src/pglite/adapter.ts
-import { logger as logger9 } from "@elizaos/core";
+import { logger as logger11 } from "@elizaos/core";
 
 // ../../node_modules/drizzle-orm/pglite/driver.js
 init_entity();
@@ -8154,7 +8976,7 @@ init_drizzle_orm();
 import {
   ChannelType,
   DatabaseAdapter,
-  logger as logger8
+  logger as logger10
 } from "@elizaos/core";
 import { v4 } from "uuid";
 
@@ -8166,33 +8988,12 @@ import { VECTOR_DIMS } from "@elizaos/core";
 // src/schema/memory.ts
 init_drizzle_orm();
 init_pg_core();
-
-// src/schema/agent.ts
-init_drizzle_orm();
-init_pg_core();
-var agentTable = pgTable("agents", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  enabled: boolean("enabled").default(true).notNull(),
-  owner_id: uuid("owner_id"),
-  createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  name: text("name").notNull(),
-  username: text("username"),
-  system: text("system").default(""),
-  bio: jsonb("bio").$type().default(sql`'[]'::jsonb`),
-  messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`).notNull(),
-  postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`).notNull(),
-  topics: jsonb("topics").$type().default(sql`'[]'::jsonb`).notNull(),
-  adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`).notNull(),
-  knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`).notNull(),
-  plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`).notNull(),
-  settings: jsonb("settings").$type().default(sql`'{}'::jsonb`).notNull(),
-  style: jsonb("style").$type().default(sql`'{}'::jsonb`).notNull()
-});
+init_agent();
 
 // src/schema/entity.ts
 init_drizzle_orm();
 init_pg_core();
+init_agent();
 var entityTable = pgTable("entities", {
   id: uuid("id").notNull().primaryKey(),
   agentId: uuid("agent_id").notNull().references(() => agentTable.id, {
@@ -8210,6 +9011,7 @@ var entityTable = pgTable("entities", {
 // src/schema/room.ts
 init_drizzle_orm();
 init_pg_core();
+init_agent();
 var roomTable = pgTable("rooms", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
   agentId: uuid("agentId").references(() => agentTable.id, {
@@ -8217,12 +9019,12 @@ var roomTable = pgTable("rooms", {
   }),
   source: text("source").notNull(),
   type: text("type").notNull(),
-  serverId: text("serverId"),
+  messageServerId: uuid("message_server_id"),
   worldId: uuid("worldId"),
   name: text("name"),
   metadata: jsonb("metadata"),
-  channelId: text("channelId"),
-  createdAt: timestamp("createdAt").default(sql`now()`).notNull()
+  channelId: text("channel_id"),
+  createdAt: timestamp("created_at").default(sql`now()`).notNull()
 });
 
 // src/schema/memory.ts
@@ -8314,17 +9116,18 @@ var embeddingTable = pgTable("embeddings", {
 ]);
 
 // src/schema/index.ts
+init_agent();
 var exports_schema = {};
 __export(exports_schema, {
   worldTable: () => worldTable,
   taskTable: () => taskTable,
-  serverAgentsTable: () => serverAgentsTable,
+  serverTable: () => serverTable,
   roomTable: () => roomTable,
   relationshipTable: () => relationshipTable,
   participantTable: () => participantTable,
-  ownersTable: () => ownersTable,
   messageTable: () => messageTable,
   messageServerTable: () => messageServerTable,
+  messageServerAgentsTable: () => messageServerAgentsTable,
   memoryTable: () => memoryTable,
   logTable: () => logTable,
   entityTable: () => entityTable,
@@ -8339,29 +9142,32 @@ __export(exports_schema, {
 // src/schema/cache.ts
 init_drizzle_orm();
 init_pg_core();
+init_agent();
 var cacheTable = pgTable("cache", {
   key: text("key").notNull(),
   agentId: uuid("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   value: jsonb("value").notNull(),
   createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
   expiresAt: timestamp("expires_at", { withTimezone: true })
-}, (table3) => ({
-  pk: primaryKey({ columns: [table3.key, table3.agentId] })
-}));
+}, (table3) => [
+  primaryKey({ columns: [table3.key, table3.agentId] })
+]);
 // src/schema/component.ts
 init_drizzle_orm();
 init_pg_core();
+init_agent();
 
 // src/schema/world.ts
 init_drizzle_orm();
 init_pg_core();
+init_agent();
 var worldTable = pgTable("worlds", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
   agentId: uuid("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   name: text("name").notNull(),
   metadata: jsonb("metadata"),
-  serverId: text("serverId").notNull().default("local"),
-  createdAt: timestamp("createdAt").default(sql`now()`).notNull()
+  messageServerId: uuid("message_server_id"),
+  createdAt: timestamp("created_at").default(sql`now()`).notNull()
 });
 
 // src/schema/component.ts
@@ -8398,17 +9204,14 @@ var logTable = pgTable("logs", {
     foreignColumns: [entityTable.id]
   }).onDelete("cascade")
 ]);
-// src/schema/owners.ts
-init_drizzle_orm();
-init_pg_core();
-var ownersTable = pgTable("owners", {
-  id: uuid("id").primaryKey(),
-  createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull()
-});
+
+// src/schema/index.ts
+init_server();
+
 // src/schema/participant.ts
 init_drizzle_orm();
 init_pg_core();
+init_agent();
 var participantTable = pgTable("participants", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
   createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
@@ -8439,6 +9242,7 @@ var participantTable = pgTable("participants", {
 // src/schema/relationship.ts
 init_drizzle_orm();
 init_pg_core();
+init_agent();
 var relationshipTable = pgTable("relationships", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
   createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
@@ -8464,6 +9268,7 @@ var relationshipTable = pgTable("relationships", {
 // src/schema/tasks.ts
 init_pg_core();
 init_drizzle_orm();
+init_agent();
 var taskTable = pgTable("tasks", {
   id: uuid("id").primaryKey().defaultRandom(),
   name: text("name").notNull(),
@@ -8471,7 +9276,7 @@ var taskTable = pgTable("tasks", {
   roomId: uuid("roomId"),
   worldId: uuid("worldId"),
   entityId: uuid("entityId"),
-  agentId: uuid("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  agentId: uuid("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text("tags").array().default(sql`'{}'::text[]`),
   metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
   createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
@@ -8494,7 +9299,7 @@ init_pg_core();
 init_drizzle_orm();
 var channelTable = pgTable("channels", {
   id: text("id").primaryKey(),
-  messageServerId: uuid("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+  messageServerId: uuid("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
   name: text("name").notNull(),
   type: text("type").notNull(),
   sourceType: text("source_type"),
@@ -8526,18 +9331,19 @@ var messageTable = pgTable("central_messages", {
 init_pg_core();
 var channelParticipantsTable = pgTable("channel_participants", {
   channelId: text("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
-  userId: text("user_id").notNull()
-}, (table3) => ({
-  pk: primaryKey({ columns: [table3.channelId, table3.userId] })
-}));
-// src/schema/serverAgent.ts
+  entityId: text("entity_id").notNull()
+}, (table3) => [
+  primaryKey({ columns: [table3.channelId, table3.entityId] })
+]);
+// src/schema/messageServerAgent.ts
 init_pg_core();
-var serverAgentsTable = pgTable("server_agents", {
-  serverId: uuid("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+init_agent();
+var messageServerAgentsTable = pgTable("message_server_agents", {
+  messageServerId: uuid("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
   agentId: uuid("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
-}, (table3) => ({
-  pk: primaryKey({ columns: [table3.serverId, table3.agentId] })
-}));
+}, (table3) => [
+  primaryKey({ columns: [table3.messageServerId, table3.agentId] })
+]);
 // src/base.ts
 class BaseDrizzleAdapter extends DatabaseAdapter {
   maxRetries = 3;
@@ -8599,10 +9405,10 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           const backoffDelay = Math.min(this.baseDelay * 2 ** (attempt - 1), this.maxDelay);
           const jitter = Math.random() * this.jitterMax;
           const delay = backoffDelay + jitter;
-          logger8.warn(`Database operation failed (attempt ${attempt}/${this.maxRetries}): ${error instanceof Error ? error.message : String(error)}, nextRetryIn: ${(delay / 1000).toFixed(1)}s`);
+          logger10.warn({ src: "plugin:sql", attempt, maxRetries: this.maxRetries, error: error instanceof Error ? error.message : String(error) }, "Database operation failed, retrying");
           await new Promise((resolve) => setTimeout(resolve, delay));
         } else {
-          logger8.error(`Max retry attempts reached: ${error instanceof Error ? error.message : String(error)}, totalAttempts: ${attempt}`);
+          logger10.error({ src: "plugin:sql", totalAttempts: attempt, error: error instanceof Error ? error.message : String(error) }, "Max retry attempts reached");
           throw error instanceof Error ? error : new Error(String(error));
         }
       }
@@ -8656,7 +9462,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         if (agent.id) {
           const existing = await this.db.select({ id: agentTable.id }).from(agentTable).where(eq(agentTable.id, agent.id)).limit(1);
           if (existing.length > 0) {
-            logger8.warn(`Attempted to create an agent with a duplicate ID. ID: ${agent.id}`);
+            logger10.warn({ src: "plugin:sql", agentId: agent.id }, "Attempted to create agent with duplicate ID");
             return false;
           }
         }
@@ -8667,10 +9473,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             updatedAt: new Date(agent.updatedAt || Date.now())
           });
         });
-        logger8.debug(`Agent created successfully: ${agent.id}`);
         return true;
       } catch (error) {
-        logger8.error(`Error creating agent: ${error instanceof Error ? error.message : String(error)}, agentId: ${agent.id}`);
+        logger10.error({ src: "plugin:sql", agentId: agent.id, error: error instanceof Error ? error.message : String(error) }, "Failed to create agent");
         return false;
       }
     });
@@ -8704,10 +9509,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           }
           await tx.update(agentTable).set(updateData).where(eq(agentTable.id, agentId));
         });
-        logger8.debug(`Agent updated successfully: ${agentId}`);
         return true;
       } catch (error) {
-        logger8.error(`Error updating agent: ${error instanceof Error ? error.message : String(error)}, agentId: ${agentId}`);
+        logger10.error({ src: "plugin:sql", agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to update agent");
         return false;
       }
     });
@@ -8749,22 +9553,16 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return finalSettings === undefined ? {} : finalSettings;
   }
   async deleteAgent(agentId) {
-    logger8.debug(`[DB] Deleting agent with ID: ${agentId}`);
     return this.withDatabase(async () => {
       try {
         const result = await this.db.delete(agentTable).where(eq(agentTable.id, agentId)).returning();
         if (result.length === 0) {
-          logger8.warn(`[DB] Agent ${agentId} not found`);
+          logger10.warn({ src: "plugin:sql", agentId }, "Agent not found for deletion");
           return false;
         }
-        logger8.success(`[DB] Agent ${agentId} and all related data successfully deleted via cascade`);
         return true;
       } catch (error) {
-        logger8.error(`[DB] Failed to delete agent ${agentId}: ${error instanceof Error ? error.message : String(error)}`);
-        if (error instanceof Error) {
-          logger8.error(`[DB] Error details: ${error.name} - ${error.message}`);
-          logger8.error(`[DB] Stack trace: ${error.stack}`);
-        }
+        logger10.error({ src: "plugin:sql", agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to delete agent");
         throw error;
       }
     });
@@ -8775,7 +9573,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const result = await this.db.select({ count: count() }).from(agentTable);
         return result[0]?.count || 0;
       } catch (error) {
-        logger8.error(`Error counting agents: ${error instanceof Error ? error.message : String(error)}`);
+        logger10.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to count agents");
         return 0;
       }
     });
@@ -8784,9 +9582,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         await this.db.delete(agentTable);
-        logger8.success("Successfully cleaned up agent table");
       } catch (error) {
-        logger8.error(`Error cleaning up agent table: ${error instanceof Error ? error.message : String(error)}`);
+        logger10.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to clean up agent table");
         throw error;
       }
     });
@@ -8865,21 +9662,17 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             metadata: entity2.metadata || {}
           }));
           await tx.insert(entityTable).values(normalizedEntities);
-          logger8.debug(`${entities.length} Entities created successfully`);
           return true;
         });
       } catch (error) {
-        logger8.error(`Error creating entities, entityId: ${entities[0].id}, (metadata?.)name: ${entities[0].metadata?.name}`, error instanceof Error ? error.message : String(error));
-        if (error instanceof Error && error.stack) {
-          logger8.trace("Stack trace:", error.stack);
-        }
+        logger10.error({ src: "plugin:sql", entityId: entities[0]?.id, error: error instanceof Error ? error.message : String(error) }, "Failed to create entities");
         return false;
       }
     });
   }
   async ensureEntityExists(entity2) {
     if (!entity2.id) {
-      logger8.error("Entity ID is required for ensureEntityExists");
+      logger10.error({ src: "plugin:sql" }, "Entity ID is required for ensureEntityExists");
       return false;
     }
     try {
@@ -8889,7 +9682,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       return true;
     } catch (error) {
-      logger8.error(`Error ensuring entity exists: ${error instanceof Error ? error.message : String(error)}, entityId: ${entity2.id}`);
+      logger10.error({ src: "plugin:sql", entityId: entity2.id, error: error instanceof Error ? error.message : String(error) }, "Failed to ensure entity exists");
       return false;
     }
   }
@@ -9057,14 +9850,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     if (offset !== undefined && offset < 0) {
       throw new Error("offset must be a non-negative number");
     }
-    return this.withDatabase(async () => {
+    return this.withEntityContext(entityId ?? null, async (tx) => {
       const conditions2 = [eq(memoryTable.type, tableName)];
       if (start) {
         conditions2.push(gte(memoryTable.createdAt, new Date(start)));
       }
-      if (entityId) {
-        conditions2.push(eq(memoryTable.entityId, entityId));
-      }
       if (roomId) {
         conditions2.push(eq(memoryTable.roomId, roomId));
       }
@@ -9080,7 +9870,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       if (agentId) {
         conditions2.push(eq(memoryTable.agentId, agentId));
       }
-      const baseQuery = this.db.select({
+      const baseQuery = tx.select({
         memory: {
           id: memoryTable.id,
           type: memoryTable.type,
@@ -9242,7 +10032,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           levenshtein_score: Number(row.levenshtein_score)
         })).filter((row) => Array.isArray(row.embedding));
       } catch (error) {
-        logger8.error(`Error in getCachedEmbeddings: ${error instanceof Error ? error.message : String(error)}, tableName: ${opts.query_table_name}, fieldName: ${opts.query_field_name}`);
+        logger10.error({ src: "plugin:sql", tableName: opts.query_table_name, fieldName: opts.query_field_name, error: error instanceof Error ? error.message : String(error) }, "Failed to get cached embeddings");
         if (error instanceof Error && error.message === "levenshtein argument exceeds maximum length of 255 characters") {
           return [];
         }
@@ -9255,7 +10045,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       try {
         const sanitizedBody = this.sanitizeJsonObject(params.body);
         const jsonString = JSON.stringify(sanitizedBody);
-        await this.db.transaction(async (tx) => {
+        await this.withEntityContext(params.entityId, async (tx) => {
           await tx.insert(logTable).values({
             body: sql`${jsonString}::jsonb`,
             entityId: params.entityId,
@@ -9264,7 +10054,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           });
         });
       } catch (error) {
-        logger8.error(`Failed to create log entry: ${error instanceof Error ? error.message : String(error)}, type: ${params.type}, roomId: ${params.roomId}, entityId: ${params.entityId}`);
+        logger10.error({ src: "plugin:sql", type: params.type, roomId: params.roomId, entityId: params.entityId, error: error instanceof Error ? error.message : String(error) }, "Failed to create log entry");
         throw error;
       }
     });
@@ -9297,8 +10087,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getLogs(params) {
     const { entityId, roomId, type, count: count2, offset } = params;
-    return this.withDatabase(async () => {
-      const result = await this.db.select().from(logTable).where(and(eq(logTable.entityId, entityId), roomId ? eq(logTable.roomId, roomId) : undefined, type ? eq(logTable.type, type) : undefined)).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
+    return this.withEntityContext(entityId ?? null, async (tx) => {
+      const result = await tx.select().from(logTable).where(and(roomId ? eq(logTable.roomId, roomId) : undefined, type ? eq(logTable.type, type) : undefined)).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
       const logs = result.map((log) => ({
         ...log,
         id: log.id,
@@ -9316,7 +10106,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     const limit = Math.min(Math.max(params.limit ?? 20, 1), 100);
     const fromDate = typeof params.from === "number" ? new Date(params.from) : undefined;
     const toDate = typeof params.to === "number" ? new Date(params.to) : undefined;
-    return this.withDatabase(async () => {
+    return this.withEntityContext(params.entityId ?? null, async (tx) => {
       const runMap = new Map;
       const conditions2 = [
         eq(logTable.type, "run_event"),
@@ -9334,7 +10124,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       const whereClause = and(...conditions2);
       const eventLimit = Math.max(limit * 20, 200);
-      const runEventRows = await this.db.select({
+      const runEventRows = await tx.select({
         runId: sql`(${logTable.body} ->> 'runId')`,
         status: sql`(${logTable.body} ->> 'status')`,
         messageId: sql`(${logTable.body} ->> 'messageId')`,
@@ -9541,11 +10331,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     });
   }
   async createMemory(memory, tableName) {
-    logger8.debug(`DrizzleAdapter createMemory: memoryId: ${memory.id}, embeddingLength: ${memory.embedding?.length}, contentLength: ${memory.content?.text?.length}`);
     const memoryId = memory.id ?? v4();
     const existing = await this.getMemoryById(memoryId);
     if (existing) {
-      logger8.debug(`Memory already exists, skipping creation: ${memoryId}`);
       return memoryId;
     }
     if (memory.unique === undefined) {
@@ -9564,7 +10352,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     }
     const contentToInsert = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
     const metadataToInsert = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
-    await this.db.transaction(async (tx) => {
+    await this.withEntityContext(memory.entityId, async (tx) => {
       await tx.insert(memoryTable).values([
         {
           id: memoryId,
@@ -9595,7 +10383,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async updateMemory(memory) {
     return this.withDatabase(async () => {
       try {
-        logger8.debug(`Updating memory: memoryId: ${memory.id}, hasEmbedding: ${!!memory.embedding}`);
         await this.db.transaction(async (tx) => {
           if (memory.content) {
             const contentToUpdate = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
@@ -9627,10 +10414,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             }
           }
         });
-        logger8.debug(`Memory updated successfully: ${memory.id}`);
         return true;
       } catch (error) {
-        logger8.error(`Error updating memory: ${error instanceof Error ? error.message : String(error)}, memoryId: ${memory.id}`);
+        logger10.error({ src: "plugin:sql", memoryId: memory.id, error: error instanceof Error ? error.message : String(error) }, "Failed to update memory");
         return false;
       }
     });
@@ -9642,7 +10428,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
         await tx.delete(memoryTable).where(eq(memoryTable.id, memoryId));
       });
-      logger8.debug(`Memory and related fragments removed successfully: ${memoryId}`);
     });
   }
   async deleteManyMemories(memoryIds) {
@@ -9661,7 +10446,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           await tx.delete(memoryTable).where(inArray(memoryTable.id, batch));
         }
       });
-      logger8.debug(`Batch memory deletion completed successfully: ${memoryIds.length}`);
     });
   }
   async deleteMemoryFragments(tx, documentId) {
@@ -9670,7 +10454,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const fragmentIds = fragmentsToDelete.map((f) => f.id);
       await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, fragmentIds));
       await tx.delete(memoryTable).where(inArray(memoryTable.id, fragmentIds));
-      logger8.debug(`Deleted related fragments: documentId: ${documentId}, fragmentCount: ${fragmentsToDelete.length}`);
     }
   }
   async getMemoryFragments(tx, documentId) {
@@ -9682,7 +10465,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       await this.db.transaction(async (tx) => {
         const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
         const ids = rows.map((r) => r.id);
-        logger8.debug(`[deleteAllMemories] memory IDs to delete: roomId: ${roomId}, tableName: ${tableName}, ids: ${JSON.stringify(ids)}`);
+        logger10.debug({ src: "plugin:sql", roomId, tableName, memoryCount: ids.length }, "Deleting all memories");
         if (ids.length === 0) {
           return;
         }
@@ -9692,7 +10475,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         }));
         await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
       });
-      logger8.debug(`All memories removed successfully: roomId: ${roomId}, tableName: ${tableName}`);
     });
   }
   async countMemories(roomId, unique2 = true, tableName = "") {
@@ -9714,7 +10496,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         name: roomTable.name,
         channelId: roomTable.channelId,
         agentId: roomTable.agentId,
-        serverId: roomTable.serverId,
+        messageServerId: roomTable.messageServerId,
         worldId: roomTable.worldId,
         type: roomTable.type,
         source: roomTable.source,
@@ -9725,7 +10507,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         id: room.id,
         name: room.name ?? undefined,
         agentId: room.agentId,
-        serverId: room.serverId,
+        messageServerId: room.messageServerId,
+        serverId: room.messageServerId,
         worldId: room.worldId,
         channelId: room.channelId,
         type: room.type,
@@ -9742,7 +10525,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         id: room.id,
         name: room.name ?? undefined,
         agentId: room.agentId,
-        serverId: room.serverId,
+        messageServerId: room.messageServerId,
+        serverId: room.messageServerId,
         worldId: room.worldId,
         channelId: room.channelId,
         type: room.type,
@@ -9799,7 +10583,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         }).onConflictDoNothing();
         return true;
       } catch (error) {
-        logger8.error(`Error adding participant to room: ${error instanceof Error ? error.message : String(error)}, entityId: ${entityId}, roomId: ${roomId}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", entityId, roomId, agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to add participant to room");
         return false;
       }
     });
@@ -9813,10 +10597,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           agentId: this.agentId
         }));
         await this.db.insert(participantTable).values(values).onConflictDoNothing().execute();
-        logger8.debug(`${entityIds.length} Entities linked successfully`);
         return true;
       } catch (error) {
-        logger8.error(`Error adding participants to room: ${error instanceof Error ? error.message : String(error)}, entityIdSample: ${entityIds[0]}, roomId: ${roomId}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", roomId, agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to add participants to room");
         return false;
       }
     });
@@ -9828,10 +10611,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           return await tx.delete(participantTable).where(and(eq(participantTable.entityId, entityId), eq(participantTable.roomId, roomId))).returning();
         });
         const removed = result.length > 0;
-        logger8.debug(`Participant ${removed ? "removed" : "not found"}: entityId: ${entityId}, roomId: ${roomId}, removed: ${removed}`);
         return removed;
       } catch (error) {
-        logger8.error(`Error removing participant from room: ${error instanceof Error ? error.message : String(error)}, entityId: ${entityId}, roomId: ${roomId}`);
+        logger10.error({ src: "plugin:sql", entityId, roomId, error: error instanceof Error ? error.message : String(error) }, "Failed to remove participant from room");
         return false;
       }
     });
@@ -9859,6 +10641,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       return result.map((row) => row.entityId);
     });
   }
+  async isRoomParticipant(roomId, entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(participantTable).where(and(eq(participantTable.roomId, roomId), eq(participantTable.entityId, entityId))).limit(1);
+      return result.length > 0;
+    });
+  }
   async getParticipantUserState(roomId, entityId) {
     return this.withDatabase(async () => {
       const result = await this.db.select({ roomState: participantTable.roomState }).from(participantTable).where(and(eq(participantTable.roomId, roomId), eq(participantTable.entityId, entityId), eq(participantTable.agentId, this.agentId))).limit(1);
@@ -9872,7 +10660,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           await tx.update(participantTable).set({ roomState: state }).where(and(eq(participantTable.roomId, roomId), eq(participantTable.entityId, entityId), eq(participantTable.agentId, this.agentId)));
         });
       } catch (error) {
-        logger8.error(`Error setting participant follow state: roomId: ${roomId}, entityId: ${entityId}, state: ${state}, error: ${error instanceof Error ? error.message : String(error)}`);
+        logger10.error({ src: "plugin:sql", roomId, entityId, state, error: error instanceof Error ? error.message : String(error) }, "Failed to set participant follow state");
         throw error;
       }
     });
@@ -9892,7 +10680,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         await this.db.insert(relationshipTable).values(saveParams);
         return true;
       } catch (error) {
-        logger8.error(`Error creating relationship: ${error instanceof Error ? error.message : String(error)}, saveParams: ${JSON.stringify(saveParams)}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), saveParams }, "Error creating relationship");
         return false;
       }
     });
@@ -9905,7 +10693,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           metadata: relationship.metadata || {}
         }).where(eq(relationshipTable.id, relationship.id));
       } catch (error) {
-        logger8.error(`Error updating relationship: ${error instanceof Error ? error.message : String(error)}, relationship: ${JSON.stringify(relationship)}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), relationshipId: relationship.id }, "Error updating relationship");
         throw error;
       }
     });
@@ -9949,12 +10737,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       return result.rows.map((relationship) => ({
         ...relationship,
         id: relationship.id,
-        sourceEntityId: relationship.sourceEntityId,
-        targetEntityId: relationship.targetEntityId,
-        agentId: relationship.agentId,
+        sourceEntityId: relationship.source_entity_id || relationship.sourceEntityId,
+        targetEntityId: relationship.target_entity_id || relationship.targetEntityId,
+        agentId: relationship.agent_id || relationship.agentId,
         tags: relationship.tags ?? [],
         metadata: relationship.metadata ?? {},
-        createdAt: relationship.createdAt ? relationship.createdAt instanceof Date ? relationship.createdAt.toISOString() : new Date(relationship.createdAt).toISOString() : new Date().toISOString()
+        createdAt: relationship.created_at || relationship.createdAt ? (relationship.created_at || relationship.createdAt) instanceof Date ? (relationship.created_at || relationship.createdAt).toISOString() : new Date(relationship.created_at || relationship.createdAt).toISOString() : new Date().toISOString()
       }));
     });
   }
@@ -9967,7 +10755,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         }
         return;
       } catch (error) {
-        logger8.error(`Error fetching cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), key }, "Error fetching cache");
         return;
       }
     });
@@ -9987,7 +10775,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         });
         return true;
       } catch (error) {
-        logger8.error(`Error setting cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), key }, "Error setting cache");
         return false;
       }
     });
@@ -10000,7 +10788,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         });
         return true;
       } catch (error) {
-        logger8.error(`Error deleting cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger10.error({ src: "plugin:sql", agentId: this.agentId, error: error instanceof Error ? error.message : String(error), key }, "Error deleting cache");
         return false;
       }
     });
@@ -10163,25 +10951,20 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, worldId), eq(roomTable.agentId, this.agentId)));
       if (rooms.length === 0) {
-        logger8.debug(`No rooms found for worldId ${worldId} and agentId ${this.agentId} to delete.`);
         return;
       }
       const roomIds = rooms.map((room) => room.id);
       if (roomIds.length > 0) {
         await this.db.delete(logTable).where(inArray(logTable.roomId, roomIds));
-        logger8.debug(`Deleted logs for ${roomIds.length} rooms in world ${worldId}.`);
         await this.db.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
-        logger8.debug(`Deleted participants for ${roomIds.length} rooms in world ${worldId}.`);
         const memoriesInRooms = await this.db.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
         const memoryIdsInRooms = memoriesInRooms.map((m) => m.id);
         if (memoryIdsInRooms.length > 0) {
           await this.db.delete(embeddingTable).where(inArray(embeddingTable.memoryId, memoryIdsInRooms));
-          logger8.debug(`Deleted embeddings for ${memoryIdsInRooms.length} memories in world ${worldId}.`);
           await this.db.delete(memoryTable).where(inArray(memoryTable.id, memoryIdsInRooms));
-          logger8.debug(`Deleted ${memoryIdsInRooms.length} memories in world ${worldId}.`);
         }
         await this.db.delete(roomTable).where(inArray(roomTable.id, roomIds));
-        logger8.debug(`Deleted ${roomIds.length} rooms for worldId ${worldId}.`);
+        logger10.debug({ src: "plugin:sql", worldId, roomsDeleted: roomIds.length, memoriesDeleted: memoryIdsInRooms.length }, "World cleanup completed");
       }
     });
   }
@@ -10245,6 +11028,26 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       } : null;
     });
   }
+  async getMessageServerByRlsServerId(rlsServerId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.execute(sql`
+        SELECT id, name, source_type, source_id, metadata, created_at, updated_at
+        FROM message_servers
+        WHERE server_id = ${rlsServerId}
+        LIMIT 1
+      `);
+      const rows = results.rows || results;
+      return rows.length > 0 ? {
+        id: rows[0].id,
+        name: rows[0].name,
+        sourceType: rows[0].source_type,
+        sourceId: rows[0].source_id || undefined,
+        metadata: rows[0].metadata || undefined,
+        createdAt: new Date(rows[0].created_at),
+        updatedAt: new Date(rows[0].updated_at)
+      } : null;
+    });
+  }
   async createChannel(data, participantIds) {
     return this.withDatabase(async () => {
       const newId = data.id || v4();
@@ -10264,9 +11067,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       await this.db.transaction(async (tx) => {
         await tx.insert(channelTable).values(channelToInsert);
         if (participantIds && participantIds.length > 0) {
-          const participantValues = participantIds.map((userId) => ({
+          const participantValues = participantIds.map((entityId) => ({
             channelId: newId,
-            userId
+            entityId
           }));
           await tx.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
         }
@@ -10274,9 +11077,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       return channelToInsert;
     });
   }
-  async getChannelsForServer(serverId) {
+  async getChannelsForMessageServer(messageServerId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select().from(channelTable).where(eq(channelTable.messageServerId, serverId));
+      const results = await this.db.select().from(channelTable).where(eq(channelTable.messageServerId, messageServerId));
       return results.map((r) => ({
         id: r.id,
         messageServerId: r.messageServerId,
@@ -10398,9 +11201,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         if (updates.participantCentralUserIds !== undefined) {
           await tx.delete(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
           if (updates.participantCentralUserIds.length > 0) {
-            const participantValues = updates.participantCentralUserIds.map((userId) => ({
+            const participantValues = updates.participantCentralUserIds.map((entityId) => ({
               channelId,
-              userId
+              entityId
             }));
             await tx.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
           }
@@ -10422,40 +11225,46 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       });
     });
   }
-  async addChannelParticipants(channelId, userIds) {
+  async addChannelParticipants(channelId, entityIds) {
     return this.withDatabase(async () => {
-      if (!userIds || userIds.length === 0)
+      if (!entityIds || entityIds.length === 0)
         return;
-      const participantValues = userIds.map((userId) => ({
+      const participantValues = entityIds.map((entityId) => ({
         channelId,
-        userId
+        entityId
       }));
       await this.db.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
     });
   }
   async getChannelParticipants(channelId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select({ userId: channelParticipantsTable.userId }).from(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
-      return results.map((r) => r.userId);
+      const results = await this.db.select({ entityId: channelParticipantsTable.entityId }).from(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
+      return results.map((r) => r.entityId);
     });
   }
-  async addAgentToServer(serverId, agentId) {
+  async isChannelParticipant(channelId, entityId) {
     return this.withDatabase(async () => {
-      await this.db.insert(serverAgentsTable).values({
-        serverId,
+      const result = await this.db.select().from(channelParticipantsTable).where(and(eq(channelParticipantsTable.channelId, channelId), eq(channelParticipantsTable.entityId, entityId))).limit(1);
+      return result.length > 0;
+    });
+  }
+  async addAgentToMessageServer(messageServerId, agentId) {
+    return this.withDatabase(async () => {
+      await this.db.insert(messageServerAgentsTable).values({
+        messageServerId,
         agentId
       }).onConflictDoNothing();
     });
   }
-  async getAgentsForServer(serverId) {
+  async getAgentsForMessageServer(messageServerId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select({ agentId: serverAgentsTable.agentId }).from(serverAgentsTable).where(eq(serverAgentsTable.serverId, serverId));
+      const results = await this.db.select({ agentId: messageServerAgentsTable.agentId }).from(messageServerAgentsTable).where(eq(messageServerAgentsTable.messageServerId, messageServerId));
       return results.map((r) => r.agentId);
     });
   }
-  async removeAgentFromServer(serverId, agentId) {
+  async removeAgentFromMessageServer(messageServerId, agentId) {
     return this.withDatabase(async () => {
-      await this.db.delete(serverAgentsTable).where(and(eq(serverAgentsTable.serverId, serverId), eq(serverAgentsTable.agentId, agentId)));
+      await this.db.delete(messageServerAgentsTable).where(and(eq(messageServerAgentsTable.messageServerId, messageServerId), eq(messageServerAgentsTable.agentId, agentId)));
     });
   }
   async findOrCreateDmChannel(user1Id, user2Id, messageServerId) {
@@ -10496,11 +11305,14 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
     this.manager = manager;
     this.db = drizzle(this.manager.getConnection());
   }
+  async withEntityContext(_entityId, callback) {
+    return this.db.transaction(callback);
+  }
   async getEntityByIds(entityIds) {
     return this.getEntitiesByIds(entityIds);
   }
   async getMemoriesByServerId(_params) {
-    logger9.warn("getMemoriesByServerId called but not implemented - returning empty array");
+    logger11.warn({ src: "plugin:sql" }, "getMemoriesByServerId called but not implemented");
     return [];
   }
   async ensureAgentExists(agent) {
@@ -10525,13 +11337,13 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
   }
   async withDatabase(operation) {
     if (this.manager.isShuttingDown()) {
-      logger9.warn("Database is shutting down");
+      logger11.warn({ src: "plugin:sql" }, "Database is shutting down");
       return null;
     }
     return operation();
   }
   async init() {
-    logger9.debug("PGliteDatabaseAdapter initialized, skipping automatic migrations.");
+    logger11.debug({ src: "plugin:sql" }, "PGliteDatabaseAdapter initialized");
   }
   async isReady() {
     return !this.manager.isShuttingDown();
@@ -10576,7 +11388,7 @@ class PGliteClientManager {
 }
 
 // src/pg/adapter.ts
-import { logger as logger10 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 
 // ../../node_modules/drizzle-orm/node-postgres/driver.js
 init_entity();
@@ -10599,12 +11411,12 @@ init_utils();
 var { Pool, types: types3 } = pg;
 
 class NodePgPreparedQuery extends PgPreparedQuery {
-  constructor(client, queryString, params, logger10, cache, queryMetadata, cacheConfig, fields, name, _isResponseInArrayMode, customResultMapper) {
+  constructor(client, queryString, params, logger12, cache, queryMetadata, cacheConfig, fields, name, _isResponseInArrayMode, customResultMapper) {
     super({ sql: queryString, params }, cache, queryMetadata, cacheConfig);
     this.client = client;
     this.queryString = queryString;
     this.params = params;
-    this.logger = logger10;
+    this.logger = logger12;
     this.fields = fields;
     this._isResponseInArrayMode = _isResponseInArrayMode;
     this.customResultMapper = customResultMapper;
@@ -10814,11 +11626,11 @@ class NodePgDatabase extends PgDatabase {
 }
 function construct2(client, config = {}) {
   const dialect2 = new PgDialect({ casing: config.casing });
-  let logger10;
+  let logger12;
   if (config.logger === true) {
-    logger10 = new DefaultLogger;
+    logger12 = new DefaultLogger;
   } else if (config.logger !== false) {
-    logger10 = config.logger;
+    logger12 = config.logger;
   }
   let schema2;
   if (config.schema) {
@@ -10829,7 +11641,7 @@ function construct2(client, config = {}) {
       tableNamesMap: tablesConfig.tableNamesMap
     };
   }
-  const driver = new NodePgDriver(client, dialect2, { logger: logger10, cache: config.cache });
+  const driver = new NodePgDriver(client, dialect2, { logger: logger12, cache: config.cache });
   const session2 = driver.createSession(schema2);
   const db2 = new NodePgDatabase(dialect2, session2, schema2);
   db2.$client = client;
@@ -10873,11 +11685,17 @@ class PgDatabaseAdapter extends BaseDrizzleAdapter {
     this.manager = manager;
     this.db = manager.getDatabase();
   }
+  getManager() {
+    return this.manager;
+  }
+  async withEntityContext(entityId, callback) {
+    return await this.manager.withEntityContext(entityId, callback);
+  }
   async getEntityByIds(entityIds) {
     return this.getEntitiesByIds(entityIds);
   }
   async getMemoriesByServerId(_params) {
-    logger10.warn("getMemoriesByServerId called but not implemented - returning empty array");
+    logger12.warn({ src: "plugin:sql" }, "getMemoriesByServerId called but not implemented");
     return [];
   }
   async ensureAgentExists(agent) {
@@ -10913,7 +11731,7 @@ class PgDatabaseAdapter extends BaseDrizzleAdapter {
     });
   }
   async init() {
-    logger10.debug("PgDatabaseAdapter initialized, skipping automatic migrations.");
+    logger12.debug({ src: "plugin:sql" }, "PgDatabaseAdapter initialized");
   }
   async isReady() {
     return this.manager.testConnection();
@@ -10975,20 +11793,21 @@ class PgDatabaseAdapter extends BaseDrizzleAdapter {
 }
 
 // src/pg/manager.ts
+init_drizzle_orm();
 import { Pool as Pool2 } from "pg";
-import { logger as logger11 } from "@elizaos/core";
+import { logger as logger13 } from "@elizaos/core";
 
 class PostgresConnectionManager {
   pool;
   db;
-  constructor(connectionString, rlsOwnerId) {
+  constructor(connectionString, rlsServerId) {
     const poolConfig = { connectionString };
-    if (rlsOwnerId) {
-      poolConfig.application_name = rlsOwnerId;
-      logger11.debug(`[RLS] Pool configured with application_name: ${rlsOwnerId}`);
+    if (rlsServerId) {
+      poolConfig.application_name = rlsServerId;
+      logger13.debug({ src: "plugin:sql", rlsServerId: rlsServerId.substring(0, 8) }, "Pool configured with RLS server");
     }
     this.pool = new Pool2(poolConfig);
-    this.db = drizzle2(this.pool);
+    this.db = drizzle2(this.pool, { casing: "snake_case" });
   }
   getDatabase() {
     return this.db;
@@ -11006,7 +11825,7 @@ class PostgresConnectionManager {
       await client.query("SELECT 1");
       return true;
     } catch (error) {
-      logger11.error(`Failed to connect to the database: ${error instanceof Error ? error.message : String(error)}`);
+      logger13.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to connect to the database");
       return false;
     } finally {
       if (client) {
@@ -11014,6 +11833,27 @@ class PostgresConnectionManager {
       }
     }
   }
+  async withEntityContext(entityId, callback) {
+    return await this.db.transaction(async (tx) => {
+      if (entityId) {
+        try {
+          await tx.execute(sql.raw(`SET LOCAL app.entity_id = '${entityId}'`));
+          logger13.debug(`[Entity Context] Set app.entity_id = ${entityId}`);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          if (errorMessage.includes("unrecognized configuration parameter") || errorMessage.includes("app.entity_id")) {
+            logger13.debug("[Entity Context] Entity RLS not enabled, executing without entity context");
+          } else {
+            logger13.error({ error, entityId }, "[Entity Context] Critical error setting entity context - this may indicate a configuration issue");
+            logger13.warn("[Entity Context] Continuing without entity context due to error - data isolation may be compromised");
+          }
+        }
+      } else {
+        logger13.debug("[Entity Context] No entity context set (server operation)");
+      }
+      return await callback(tx);
+    });
+  }
   async close() {
     await this.pool.end();
   }
@@ -11071,246 +11911,7 @@ function resolvePgliteDir(dir, fallbackDir) {
 
 // src/index.node.ts
 init_migration_service();
-
-// src/rls.ts
-init_drizzle_orm();
-import { logger as logger12, validateUuid } from "@elizaos/core";
-async function installRLSFunctions(adapter) {
-  const db2 = adapter.db;
-  await db2.execute(sql`
-    CREATE TABLE IF NOT EXISTS owners (
-      id UUID PRIMARY KEY,
-      created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
-      updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
-    )
-  `);
-  await db2.execute(sql`
-    CREATE OR REPLACE FUNCTION current_owner_id() RETURNS UUID AS $$
-    DECLARE
-      app_name TEXT;
-    BEGIN
-      app_name := NULLIF(current_setting('application_name', TRUE), '');
-
-      -- Return NULL if application_name is not set or not a valid UUID
-      -- This allows admin queries to work without RLS restrictions
-      BEGIN
-        RETURN app_name::UUID;
-      EXCEPTION WHEN OTHERS THEN
-        RETURN NULL;
-      END;
-    END;
-    $$ LANGUAGE plpgsql STABLE;
-  `);
-  await db2.execute(sql`
-    CREATE OR REPLACE FUNCTION add_owner_isolation(
-      schema_name text,
-      table_name text
-    ) RETURNS void AS $$
-    DECLARE
-      full_table_name text;
-      column_exists boolean;
-      orphaned_count bigint;
-    BEGIN
-      full_table_name := schema_name || '.' || table_name;
-
-      -- Check if owner_id column already exists
-      SELECT EXISTS (
-        SELECT 1 FROM information_schema.columns
-        WHERE information_schema.columns.table_schema = schema_name
-          AND information_schema.columns.table_name = add_owner_isolation.table_name
-          AND information_schema.columns.column_name = 'owner_id'
-      ) INTO column_exists;
-
-      -- Add owner_id column if missing (DEFAULT populates it automatically for new rows)
-      IF NOT column_exists THEN
-        EXECUTE format('ALTER TABLE %I.%I ADD COLUMN owner_id UUID DEFAULT current_owner_id()', schema_name, table_name);
-
-        -- Backfill existing rows with current owner_id
-        -- This ensures all existing data belongs to the tenant that is enabling RLS
-        EXECUTE format('UPDATE %I.%I SET owner_id = current_owner_id() WHERE owner_id IS NULL', schema_name, table_name);
-      ELSE
-        -- Column already exists (RLS was previously enabled then disabled)
-        -- Restore the DEFAULT clause (may have been removed during uninstallRLS)
-        EXECUTE format('ALTER TABLE %I.%I ALTER COLUMN owner_id SET DEFAULT current_owner_id()', schema_name, table_name);
-
-        -- Only backfill NULL owner_id rows, do NOT steal data from other owners
-        EXECUTE format('SELECT COUNT(*) FROM %I.%I WHERE owner_id IS NULL', schema_name, table_name) INTO orphaned_count;
-
-        IF orphaned_count > 0 THEN
-          RAISE NOTICE 'Backfilling % rows with NULL owner_id in %.%', orphaned_count, schema_name, table_name;
-          EXECUTE format('UPDATE %I.%I SET owner_id = current_owner_id() WHERE owner_id IS NULL', schema_name, table_name);
-        END IF;
-      END IF;
-
-      -- Create index for efficient owner_id filtering
-      EXECUTE format('CREATE INDEX IF NOT EXISTS idx_%I_owner_id ON %I.%I(owner_id)', table_name, schema_name, table_name);
-
-      -- Enable RLS on the table
-      EXECUTE format('ALTER TABLE %I.%I ENABLE ROW LEVEL SECURITY', schema_name, table_name);
-
-      -- FORCE RLS even for table owners (critical for security)
-      EXECUTE format('ALTER TABLE %I.%I FORCE ROW LEVEL SECURITY', schema_name, table_name);
-
-      -- Drop existing policy if present
-      EXECUTE format('DROP POLICY IF EXISTS owner_isolation_policy ON %I.%I', schema_name, table_name);
-
-      -- Create isolation policy: users can only see/modify rows where owner_id matches current tenant
-      -- No NULL clause - all rows must have a valid owner_id (backfilled during column addition)
-      EXECUTE format('
-        CREATE POLICY owner_isolation_policy ON %I.%I
-        USING (owner_id = current_owner_id())
-        WITH CHECK (owner_id = current_owner_id())
-      ', schema_name, table_name);
-    END;
-    $$ LANGUAGE plpgsql;
-  `);
-  await db2.execute(sql`
-    CREATE OR REPLACE FUNCTION apply_rls_to_all_tables() RETURNS void AS $$
-    DECLARE
-      tbl record;
-    BEGIN
-      FOR tbl IN
-        SELECT schemaname, tablename
-        FROM pg_tables
-        WHERE schemaname = 'public'
-          AND tablename NOT IN (
-            'owners',
-            'drizzle_migrations',
-            '__drizzle_migrations',
-            'server_agents'
-          )
-      LOOP
-        BEGIN
-          PERFORM add_owner_isolation(tbl.schemaname, tbl.tablename);
-        EXCEPTION WHEN OTHERS THEN
-          RAISE WARNING 'Failed to apply RLS to %.%: %', tbl.schemaname, tbl.tablename, SQLERRM;
-        END;
-      END LOOP;
-    END;
-    $$ LANGUAGE plpgsql;
-  `);
-  logger12.info("[RLS] PostgreSQL functions installed");
-}
-async function getOrCreateRlsOwner(adapter, ownerId) {
-  const db2 = adapter.db;
-  await db2.insert(ownersTable).values({
-    id: ownerId
-  }).onConflictDoNothing();
-  logger12.info(`[RLS] Owner: ${ownerId.slice(0, 8)}…`);
-  return ownerId;
-}
-async function setOwnerContext(adapter, ownerId) {
-  if (!validateUuid(ownerId)) {
-    throw new Error(`Invalid owner ID format: ${ownerId}. Must be a valid UUID.`);
-  }
-  const db2 = adapter.db;
-  const owners = await db2.select().from(ownersTable).where(eq(ownersTable.id, ownerId));
-  if (owners.length === 0) {
-    throw new Error(`Owner ${ownerId} does not exist`);
-  }
-  logger12.info(`[RLS] Owner: ${ownerId.slice(0, 8)}…`);
-  logger12.info("[RLS] Context configured successfully (using application_name)");
-}
-async function assignAgentToOwner(adapter, agentId, ownerId) {
-  const db2 = adapter.db;
-  const agents = await db2.select().from(agentTable).where(eq(agentTable.id, agentId));
-  if (agents.length > 0) {
-    const agent = agents[0];
-    const currentOwnerId = agent.owner_id;
-    if (currentOwnerId === ownerId) {
-      logger12.debug(`[RLS] Agent ${agent.name} already owned by correct owner`);
-    } else {
-      await db2.update(agentTable).set({ owner_id: ownerId }).where(eq(agentTable.id, agentId));
-      if (currentOwnerId === null) {
-        logger12.info(`[RLS] Agent ${agent.name} assigned to owner`);
-      } else {
-        logger12.warn(`[RLS] Agent ${agent.name} owner changed`);
-      }
-    }
-  } else {
-    logger12.debug(`[RLS] Agent ${agentId} doesn't exist yet`);
-  }
-}
-async function applyRLSToNewTables(adapter) {
-  const db2 = adapter.db;
-  try {
-    await db2.execute(sql`SELECT apply_rls_to_all_tables()`);
-    logger12.info("[RLS] Applied to all tables");
-  } catch (error) {
-    logger12.warn("[RLS] Failed to apply to some tables:", String(error));
-  }
-}
-async function uninstallRLS(adapter) {
-  const db2 = adapter.db;
-  try {
-    const checkResult = await db2.execute(sql`
-      SELECT EXISTS (
-        SELECT FROM pg_tables
-        WHERE schemaname = 'public' AND tablename = 'owners'
-      ) as rls_enabled
-    `);
-    const rlsEnabled = checkResult.rows?.[0]?.rls_enabled;
-    if (!rlsEnabled) {
-      logger12.debug("[RLS] RLS not installed, skipping cleanup");
-      return;
-    }
-    logger12.info("[RLS] Disabling RLS globally (keeping owner_id columns for schema compatibility)...");
-    await db2.execute(sql`
-      CREATE OR REPLACE FUNCTION _temp_disable_rls_on_table(
-        p_schema_name text,
-        p_table_name text
-      ) RETURNS void AS $$
-      DECLARE
-        policy_rec record;
-      BEGIN
-        -- Drop all policies on this table
-        FOR policy_rec IN
-          SELECT policyname
-          FROM pg_policies
-          WHERE schemaname = p_schema_name AND tablename = p_table_name
-        LOOP
-          EXECUTE format('DROP POLICY IF EXISTS %I ON %I.%I',
-            policy_rec.policyname, p_schema_name, p_table_name);
-        END LOOP;
-
-        -- Disable RLS
-        EXECUTE format('ALTER TABLE %I.%I NO FORCE ROW LEVEL SECURITY', p_schema_name, p_table_name);
-        EXECUTE format('ALTER TABLE %I.%I DISABLE ROW LEVEL SECURITY', p_schema_name, p_table_name);
-      END;
-      $$ LANGUAGE plpgsql;
-    `);
-    const tablesResult = await db2.execute(sql`
-      SELECT schemaname, tablename
-      FROM pg_tables
-      WHERE schemaname = 'public'
-        AND tablename NOT IN ('drizzle_migrations', '__drizzle_migrations')
-    `);
-    for (const row of tablesResult.rows || []) {
-      const schemaName = row.schemaname;
-      const tableName = row.tablename;
-      try {
-        await db2.execute(sql`SELECT _temp_disable_rls_on_table(${schemaName}, ${tableName})`);
-        logger12.debug(`[RLS] Disabled RLS on table: ${schemaName}.${tableName}`);
-      } catch (error) {
-        logger12.warn(`[RLS] Failed to disable RLS on table ${schemaName}.${tableName}:`, String(error));
-      }
-    }
-    await db2.execute(sql`DROP FUNCTION IF EXISTS _temp_disable_rls_on_table(text, text)`);
-    logger12.info("[RLS] Keeping owner_id values intact (prevents data theft on re-enable)");
-    logger12.info("[RLS] Clearing owners table...");
-    await db2.execute(sql`TRUNCATE TABLE owners`);
-    await db2.execute(sql`DROP FUNCTION IF EXISTS apply_rls_to_all_tables() CASCADE`);
-    await db2.execute(sql`DROP FUNCTION IF EXISTS add_owner_isolation(text, text) CASCADE`);
-    await db2.execute(sql`DROP FUNCTION IF EXISTS current_owner_id() CASCADE`);
-    logger12.info("[RLS] Dropped all RLS functions");
-    logger12.success("[RLS] RLS disabled successfully (owner_id columns preserved)");
-  } catch (error) {
-    logger12.error("[RLS] Failed to disable RLS:", String(error));
-    throw error;
-  }
-}
-
-// src/index.node.ts
+init_rls();
 var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
 var globalSymbols = globalThis;
 if (!globalSymbols[GLOBAL_SINGLETONS]) {
@@ -11319,30 +11920,33 @@ if (!globalSymbols[GLOBAL_SINGLETONS]) {
 var globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
 function createDatabaseAdapter(config, agentId) {
   if (config.postgresUrl) {
-    const rlsEnabled = process.env.ENABLE_RLS_ISOLATION === "true";
-    let rlsOwnerId;
+    const dataIsolationEnabled = process.env.ENABLE_DATA_ISOLATION === "true";
+    let rlsServerId;
     let managerKey = "default";
-    if (rlsEnabled) {
-      const rlsOwnerIdString = process.env.RLS_OWNER_ID;
-      if (!rlsOwnerIdString) {
-        throw new Error("[RLS] ENABLE_RLS_ISOLATION=true requires RLS_OWNER_ID environment variable");
+    if (dataIsolationEnabled) {
+      const rlsServerIdString = process.env.ELIZA_SERVER_ID;
+      if (!rlsServerIdString) {
+        throw new Error("[Data Isolation] ENABLE_DATA_ISOLATION=true requires ELIZA_SERVER_ID environment variable");
       }
-      rlsOwnerId = stringToUuid(rlsOwnerIdString);
-      managerKey = rlsOwnerId;
-      logger13.debug(`[RLS] Using connection pool for owner_id: ${rlsOwnerId.slice(0, 8)}… (from RLS_OWNER_ID="${rlsOwnerIdString}")`);
+      rlsServerId = stringToUuid(rlsServerIdString);
+      managerKey = rlsServerId;
+      logger14.debug({ src: "plugin:sql", rlsServerId: rlsServerId.slice(0, 8), serverIdString: rlsServerIdString }, "Using connection pool for RLS server");
     }
     if (!globalSingletons.postgresConnectionManagers) {
       globalSingletons.postgresConnectionManagers = new Map;
     }
     let manager = globalSingletons.postgresConnectionManagers.get(managerKey);
     if (!manager) {
-      logger13.debug(`[RLS] Creating new connection pool for key: ${managerKey.slice(0, 8)}…`);
-      manager = new PostgresConnectionManager(config.postgresUrl, rlsOwnerId);
+      logger14.debug({ src: "plugin:sql", managerKey: managerKey.slice(0, 8) }, "Creating new connection pool");
+      manager = new PostgresConnectionManager(config.postgresUrl, rlsServerId);
       globalSingletons.postgresConnectionManagers.set(managerKey, manager);
     }
     return new PgDatabaseAdapter(agentId, manager);
   }
   const dataDir = resolvePgliteDir(config.dataDir);
+  if (dataDir && !dataDir.includes("://")) {
+    mkdirSync(dataDir, { recursive: true });
+  }
   if (!globalSingletons.pgLiteClientManager) {
     globalSingletons.pgLiteClientManager = new PGliteClientManager({ dataDir });
   }
@@ -11354,18 +11958,18 @@ var plugin = {
   priority: 0,
   schema: exports_schema,
   init: async (_config, runtime) => {
-    logger13.info("plugin-sql (node) init starting...");
+    runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "plugin-sql (node) init starting");
     const adapterRegistered = await runtime.isReady().then(() => true).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("Database adapter not registered")) {
-        logger13.info("No pre-registered database adapter detected; registering adapter");
+        runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "No pre-registered database adapter detected; registering adapter");
       } else {
-        logger13.warn({ error }, "Database adapter readiness check error; proceeding to register adapter");
+        runtime.logger.warn({ src: "plugin:sql", agentId: runtime.agentId, error: message }, "Database adapter readiness check error; proceeding to register adapter");
       }
       return false;
     });
     if (adapterRegistered) {
-      logger13.info("Database adapter already registered, skipping creation");
+      runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "Database adapter already registered, skipping creation");
       return;
     }
     const postgresUrl = runtime.getSetting("POSTGRES_URL");
@@ -11375,22 +11979,22 @@ var plugin = {
       postgresUrl
     }, runtime.agentId);
     runtime.registerDatabaseAdapter(dbAdapter);
-    logger13.info("Database adapter created and registered");
+    runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "Database adapter created and registered");
   }
 };
 var index_node_default = plugin;
 export {
   uninstallRLS,
-  setOwnerContext,
+  setServerContext,
   plugin,
   installRLSFunctions,
-  getOrCreateRlsOwner,
+  getOrCreateRlsServer,
   index_node_default as default,
   createDatabaseAdapter,
-  assignAgentToOwner,
+  assignAgentToServer,
   applyRLSToNewTables,
   DatabaseMigrationService
 };
 
-//# debugId=A92CE19BE9F182BF64756E2164756E21
+//# debugId=C2608A88C2C2BA8564756E2164756E21
 //# sourceMappingURL=index.node.js.map