opcode-pg-memory 2.2.5 → 2.2.6

package/dist/index.js

@@ -11194,6 +11194,48 @@ var defaults = import_lib.default.defaults;
 
 // src/db/init-db.ts
 var import_pgvector = __toESM(require_src(), 1);
+
+// src/services/logger.ts
+var LEVEL_MAP = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LEVEL_NAMES = {
+  debug: "DEBUG",
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR"
+};
+function getConfiguredLevel() {
+  const env = process.env.PG_MEMORY_LOG_LEVEL ?? "info";
+  const level = env.toLowerCase();
+  if (level in LEVEL_MAP) {
+    return LEVEL_MAP[level];
+  }
+  return LEVEL_MAP.info;
+}
+var currentLevel = getConfiguredLevel();
+function log(level, module, msg, data) {
+  if (currentLevel > LEVEL_MAP[level]) {
+    return;
+  }
+  const line = data !== undefined ? `[PG Memory] [${LEVEL_NAMES[level]}] [${module}] ${msg} ${JSON.stringify(data)}
+` : `[PG Memory] [${LEVEL_NAMES[level]}] [${module}] ${msg}
+`;
+  process.stderr.write(line);
+}
+function createLogger(module) {
+  return {
+    debug: (msg, data) => log("debug", module, msg, data),
+    info: (msg, data) => log("info", module, msg, data),
+    warn: (msg, data) => log("warn", module, msg, data),
+    error: (msg, data) => log("error", module, msg, data)
+  };
+}
+
+// src/db/init-db.ts
 var DEFAULT_DB_CONFIG = {
   host: process.env.PG_HOST || "localhost",
   port: parseInt(process.env.PG_PORT || "5432", 10),
@@ -11207,6 +11249,7 @@ var DEFAULT_DB_CONFIG = {
 class DatabaseInitializer {
   pool = null;
   config;
+  logger = createLogger("init-db");
   constructor(config = {}) {
     this.config = { ...DEFAULT_DB_CONFIG, ...config };
   }
@@ -11233,9 +11276,9 @@ class DatabaseInitializer {
       const client = await this.pool.connect();
       const result = await client.query("SELECT NOW() as now");
       client.release();
-      console.log("[PG Memory] Database connected:", result.rows[0].now);
+      this.logger.info("Database connected:", result.rows[0].now);
     } catch (error) {
-      console.error("[PG Memory] Database connection failed:", error);
+      this.logger.error("Database connection failed:", error);
       throw new Error(`Failed to connect to PostgreSQL: ${error}`);
     }
   }
@@ -11251,10 +11294,10 @@ class DatabaseInitializer {
       await this.migrateSessionsData(client);
       await this.initializeOmOSchema(client);
       await client.query("COMMIT");
-      console.log("[PG Memory] Database schema initialized successfully");
+      this.logger.info("Database schema initialized successfully");
     } catch (error) {
       await client.query("ROLLBACK");
-      console.error("[PG Memory] Database setup failed:", error);
+      this.logger.error("Database setup failed:", error);
       throw error;
     } finally {
       client.release();
@@ -11265,7 +11308,7 @@ class DatabaseInitializer {
       CREATE EXTENSION IF NOT EXISTS vector;
       CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
     `);
-    console.log("[PG Memory] Extensions created");
+    this.logger.info("Extensions created");
   }
   async createEnums(client) {
     await client.query(`
@@ -11280,7 +11323,7 @@ class DatabaseInitializer {
         END IF;
       END $$;
     `);
-    console.log("[PG Memory] Enums created");
+    this.logger.info("Enums created");
   }
   async createTables(client) {
     await client.query(`
@@ -11419,7 +11462,7 @@ class DatabaseInitializer {
         created_at TIMESTAMPTZ DEFAULT NOW()
       );
     `);
-    console.log("[PG Memory] Tables created");
+    this.logger.info("Tables created");
   }
   async createIndexes(client) {
     await client.query(`
@@ -11513,7 +11556,7 @@ class DatabaseInitializer {
       DROP INDEX IF EXISTS idx_reflection_errors_session;
       DROP INDEX IF EXISTS idx_token_usage_session;
     `);
-    console.log("[PG Memory] Indexes created");
+    this.logger.info("Indexes created");
   }
   async migrateLegacyColumnNames(client) {
     const tables = [
@@ -11539,13 +11582,13 @@ class DatabaseInitializer {
           await client.query(`
             ALTER TABLE "${table}" RENAME COLUMN session_id TO session_map_id
           `);
-          console.log(`[PG Memory] Renamed ${table}.session_id → session_map_id`);
+          this.logger.info(`Renamed ${table}.session_id → session_map_id`);
         }
       } catch (err) {
-        console.log(`[PG Memory] Skipped column rename for ${table}: ${err}`);
+        this.logger.info(`Skipped column rename for ${table}: ${err}`);
       }
     }
-    console.log("[PG Memory] Legacy column migration complete");
+    this.logger.info("Legacy column migration complete");
   }
   async migrateSessionsData(client) {
     try {
@@ -11554,7 +11597,7 @@ class DatabaseInitializer {
         WHERE table_schema = 'public' AND table_name = 'sessions'
       `);
       if (exists.rows.length === 0) {
-        console.log("[PG Memory] No legacy sessions table found, skipping migration");
+        this.logger.info("No legacy sessions table found, skipping migration");
         return;
       }
       await client.query(`
@@ -11566,18 +11609,18 @@ class DatabaseInitializer {
         FROM sessions
         ON CONFLICT (opencode_session_id) DO NOTHING;
       `);
-      console.log("[PG Memory] Legacy sessions data migrated to session_map");
+      this.logger.info("Legacy sessions data migrated to session_map");
     } catch (error) {
-      console.warn("[PG Memory] Sessions migration warning (non-fatal):", error);
+      this.logger.warn("Sessions migration warning (non-fatal):", error);
     }
   }
   async initializeOmOSchema(client) {
     const omOEnabled = process.env.OMO_ENABLED === "true" || process.env.OMO_INTEGRATION === "enabled";
     if (!omOEnabled) {
-      console.log("[PG Memory] OmO integration not enabled, skipping OmO schema");
+      this.logger.info("OmO integration not enabled, skipping OmO schema");
       return;
     }
-    console.log("[PG Memory] Initializing OmO schema...");
+    this.logger.info("Initializing OmO schema...");
     const tablesWithAgent = ["observations", "semantic_cache", "entities", "reflections"];
     for (const table of tablesWithAgent) {
       try {
@@ -11593,7 +11636,7 @@ class DatabaseInitializer {
           CREATE INDEX IF NOT EXISTS idx_${table}_agent_task ON ${table}(agent_task_id)
         `);
       } catch (error) {
-        console.warn(`[PG Memory] Schema update warning for ${table}:`, error);
+        this.logger.warn(`Schema update warning for ${table}:`, error);
       }
     }
     await client.query(`
@@ -11631,13 +11674,13 @@ class DatabaseInitializer {
     await client.query(`
       CREATE INDEX IF NOT EXISTS idx_omo_wisdom_type ON omo_wisdom(type)
     `);
-    console.log("[PG Memory] OmO schema initialized");
+    this.logger.info("OmO schema initialized");
   }
   async close() {
     if (this.pool) {
       await this.pool.end();
       this.pool = null;
-      console.log("[PG Memory] Database connection closed");
+      this.logger.info("Database connection closed");
     }
   }
   getPool() {
@@ -11769,6 +11812,7 @@ function checkBudgetOverflow(facts, budget) {
 }
 
 // src/hooks/session-created.ts
+var logger = createLogger("session-created");
 var DEFAULT_CONFIG = {
   contextLimitRatio: 0.05,
   minTokens: 500,
@@ -11779,7 +11823,7 @@ var DEFAULT_CONFIG = {
 async function handleSessionCreated(input, output, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG, ...config };
   const { session } = input;
-  console.log(`[PG Memory] Session created: ${session.id}`);
+  logger.info(`Session created: ${session.id}`);
   try {
     await upsertSession(session, pool);
     const budget = calculateTokenBudget(session.model.contextLimit, {
@@ -11787,13 +11831,13 @@ async function handleSessionCreated(input, output, pool, config = {}) {
       minTokens: mergedConfig.minTokens,
       maxTokens: mergedConfig.maxTokens
     });
-    console.log(`[PG Memory] Token budget for injection: ${budget}`);
+    logger.info(`Token budget for injection: ${budget}`);
     const facts = await retrieveFactsForInjection(session.id, budget, pool, mergedConfig);
-    console.log(`[PG Memory] Retrieved ${facts.length} facts for injection`);
+    logger.info(`Retrieved ${facts.length} facts for injection`);
     const memories = facts.map((f) => f.content);
     output.context = { memories };
   } catch (error) {
-    console.error("[PG Memory] Error handling session.created:", error);
+    logger.error("Error handling session.created:", error);
   }
 }
 async function upsertSession(session, pool) {
@@ -11939,6 +11983,7 @@ function stripPrivateContent(content) {
 }
 
 // src/hooks/tool-execute.ts
+var logger2 = createLogger("tool-execute");
 var DEFAULT_CONFIG2 = {
   maxInputSummaryLength: 500,
   maxOutputSummaryLength: 1000,
@@ -11947,11 +11992,11 @@ var DEFAULT_CONFIG2 = {
 async function handleToolExecuteBefore(input, output, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG2, ...config };
   const { session, tool, messageId } = input;
-  console.log(`[PG Memory] Tool execute before: ${tool.name}`);
+  logger2.info(`Tool execute before: ${tool.name}`);
   try {
-    const sessionResult = await pool.query("SELECT id FROM sessions WHERE external_id = $1", [session.id]);
+    const sessionResult = await pool.query("SELECT id FROM session_map WHERE opencode_session_id = $1", [session.id]);
     if (sessionResult.rows.length === 0) {
-      console.warn(`[PG Memory] Session not found: ${session.id}`);
+      logger2.warn(`Session not found: ${session.id}`);
       return;
     }
     const sessionInternalId = sessionResult.rows[0].id;
@@ -11976,19 +12021,19 @@ async function handleToolExecuteBefore(input, output, pool, config = {}) {
         parameters: sanitizeParameters(tool.parameters)
       })
     ]);
-    console.log(`[PG Memory] Recorded tool input: ${tool.name}`);
+    logger2.info(`Recorded tool input: ${tool.name}`);
   } catch (error) {
-    console.error("[PG Memory] Error handling tool.execute.before:", error);
+    logger2.error("Error handling tool.execute.before:", error);
   }
 }
 async function handleToolExecuteAfter(input, output, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG2, ...config };
   const { session, tool, result, messageId, executionTimeMs } = input;
-  console.log(`[PG Memory] Tool execute after: ${tool.name}, success: ${result.success}`);
+  logger2.info(`Tool execute after: ${tool.name}, success: ${result.success}`);
   try {
-    const sessionResult = await pool.query("SELECT id FROM sessions WHERE external_id = $1", [session.id]);
+    const sessionResult = await pool.query("SELECT id FROM session_map WHERE opencode_session_id = $1", [session.id]);
     if (sessionResult.rows.length === 0) {
-      console.warn(`[PG Memory] Session not found: ${session.id}`);
+      logger2.warn(`Session not found: ${session.id}`);
       return;
     }
     const sessionInternalId = sessionResult.rows[0].id;
@@ -12018,7 +12063,7 @@ async function handleToolExecuteAfter(input, output, pool, config = {}) {
         }),
         observationId
       ]);
-      console.log(`[PG Memory] Updated observation: ${observationId}`);
+      logger2.info(`Updated observation: ${observationId}`);
     } else {
       await pool.query(`
         INSERT INTO observations (
@@ -12041,7 +12086,7 @@ async function handleToolExecuteAfter(input, output, pool, config = {}) {
           event: "tool.execute.after"
         })
       ]);
-      console.log(`[PG Memory] Created new observation for tool output`);
+      logger2.info("Created new observation for tool output");
     }
     const estimatedTokens = estimateToolTokens(tool.name, result);
     await pool.query(`
@@ -12058,7 +12103,7 @@ async function handleToolExecuteAfter(input, output, pool, config = {}) {
       })
     ]);
   } catch (error) {
-    console.error("[PG Memory] Error handling tool.execute.after:", error);
+    logger2.error("Error handling tool.execute.after:", error);
   }
 }
 function summarizeToolInput(parameters, maxLength) {
@@ -12130,6 +12175,7 @@ function estimateToolTokens(toolName, result) {
 }
 
 // src/hooks/message-updated.ts
+var logger3 = createLogger("message-updated");
 var DEFAULT_CONFIG3 = {
   minConfidence: 0.5,
   minEntityNameLength: 2,
@@ -12139,18 +12185,18 @@ var DEFAULT_CONFIG3 = {
 async function handleMessageUpdated(input, output, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG3, ...config };
   const { session, message } = input;
-  console.log(`[PG Memory] Message updated: ${message.id}, role: ${message.role}`);
+  logger3.info(`Message updated: ${message.id}, role: ${message.role}`);
   try {
-    storeMessage(session.id, message, pool).catch((err) => console.warn("[PG Memory] Failed to store message:", err.message));
-    const sessionResult = await pool.query("SELECT id FROM sessions WHERE external_id = $1", [session.id]);
+    storeMessage(session.id, message, pool).catch((err) => logger3.warn("Failed to store message:", err.message));
+    const sessionResult = await pool.query("SELECT id FROM session_map WHERE opencode_session_id = $1", [session.id]);
     if (sessionResult.rows.length === 0) {
-      console.warn(`[PG Memory] Session not found: ${session.id}`);
+      logger3.warn(`Session not found: ${session.id}`);
       return;
     }
     const sessionInternalId = sessionResult.rows[0].id;
-    extractEntitiesAndRelations(sessionInternalId, message.content, session.id, pool, mergedConfig).catch((err) => console.warn("[PG Memory] Failed to extract entities:", err.message));
+    extractEntitiesAndRelations(sessionInternalId, message.content, session.id, pool, mergedConfig).catch((err) => logger3.warn("Failed to extract entities:", err.message));
   } catch (error) {
-    console.error("[PG Memory] Error handling message.updated:", error);
+    logger3.error("Error handling message.updated:", error);
   }
 }
 async function storeMessage(sessionId, message, pool) {
@@ -12191,7 +12237,7 @@ async function storeMessage(sessionId, message, pool) {
         completed_at,
         embedding
       ) VALUES (
-        (SELECT id FROM sessions WHERE external_id = $1),
+        (SELECT id FROM session_map WHERE opencode_session_id = $1),
         $2, $3, $4, $5, $6, $7,
         $8, $9, $10, $11, $12, $13, $14, $15, $16,
         TO_TIMESTAMP($17/1000), 
@@ -12230,15 +12276,15 @@ async function storeMessage(sessionId, message, pool) {
       message.time?.created || Date.now(),
       message.time?.completed
     ]);
-    console.log(`[PG Memory] Stored message: ${message.id} (${message.role}, ${tokenTotal} tokens)`);
+    logger3.info(`Stored message: ${message.id} (${message.role}, ${tokenTotal} tokens)`);
   } catch (error) {
-    console.error("[PG Memory] Failed to store message:", error);
+    logger3.error("Failed to store message:", error);
     throw error;
   }
 }
 async function extractEntitiesAndRelations(sessionId, content, externalSessionId, pool, config) {
   const extractedEntities = await extractEntities(content, sessionId, pool, config);
-  console.log(`[PG Memory] Extracted ${extractedEntities.length} entities`);
+  logger3.info(`Extracted ${extractedEntities.length} entities`);
   if (extractedEntities.length >= 2) {
     await extractAndStoreRelations(extractedEntities, content, sessionId, pool, config);
   }
@@ -12274,7 +12320,7 @@ async function extractEntities(content, sessionId, pool, config) {
         name: extracted.name,
         type: extracted.type
       });
-      console.log(`[PG Memory] Updated entity: ${extracted.name} (weight: ${(currentWeight + 0.1).toFixed(2)})`);
+      logger3.info(`Updated entity: ${extracted.name} (weight: ${(currentWeight + 0.1).toFixed(2)})`);
     } else {
       const tier = determineEntityTier(extracted.type, content);
       const insertResult = await pool.query(`
@@ -12299,7 +12345,7 @@ async function extractEntities(content, sessionId, pool, config) {
         name: extracted.name,
         type: extracted.type
       });
-      console.log(`[PG Memory] Created entity: ${extracted.name} (${extracted.type})`);
+      logger3.info(`Created entity: ${extracted.name} (${extracted.type})`);
     }
   }
   return entities;
@@ -12379,7 +12425,7 @@ async function extractAndStoreRelations(entities, content, sessionId, pool, conf
             sessionId
           ]);
           relationsCreated++;
-          console.log(`[PG Memory] Created relation: ${source.name} ${relationType} ${target.name}`);
+          logger3.info(`Created relation: ${source.name} ${relationType} ${target.name}`);
         }
       }
     }
@@ -12410,6 +12456,7 @@ function inferRelationType(sourceType, targetType, content) {
 }
 
 // src/hooks/message-part-updated.ts
+var logger4 = createLogger("message-part-updated");
 var partAccumulators = new Map;
 function cleanupExpiredAccumulators(maxAgeMs = 300000) {
   const now = Date.now();
@@ -12421,12 +12468,13 @@ function cleanupExpiredAccumulators(maxAgeMs = 300000) {
     }
   }
   if (cleaned > 0) {
-    console.log(`[PG Memory] Cleaned up ${cleaned} expired accumulators`);
+    logger4.info(`Cleaned up ${cleaned} expired accumulators`);
   }
 }
 setInterval(() => cleanupExpiredAccumulators(), 300000);
 
 // src/hooks/session-compacting.ts
+var logger5 = createLogger("session-compacting");
 var DEFAULT_CONFIG4 = {
   preserveHighImportanceObservations: true,
   minImportanceToPreserve: 4,
@@ -12435,11 +12483,11 @@ var DEFAULT_CONFIG4 = {
 async function handleSessionCompacting(input, output, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG4, ...config };
   const { session, messagesToCompact, compactionStrategy } = input;
-  console.log(`[PG Memory] Session compacting: ${session.id}, strategy: ${compactionStrategy}, messages: ${messagesToCompact.length}`);
+  logger5.info(`Session compacting: ${session.id}, strategy: ${compactionStrategy}, messages: ${messagesToCompact.length}`);
   try {
-    const sessionResult = await pool.query("SELECT id FROM sessions WHERE external_id = $1", [session.id]);
+    const sessionResult = await pool.query("SELECT id FROM session_map WHERE opencode_session_id = $1", [session.id]);
     if (sessionResult.rows.length === 0) {
-      console.warn(`[PG Memory] Session not found: ${session.id}`);
+      logger5.warn(`Session not found: ${session.id}`);
       return;
     }
     const sessionInternalId = sessionResult.rows[0].id;
@@ -12460,12 +12508,12 @@ async function handleSessionCompacting(input, output, pool, config = {}) {
         strategy: compactionStrategy
       })
     ]);
-    console.log(`[PG Memory] Session compacting complete. Preserved ${preserveMessageIds.length} high-value messages`);
+    logger5.info(`Session compacting complete. Preserved ${preserveMessageIds.length} high-value messages`);
     if (preserveMessageIds.length > 0) {
       output.preserveMessageIds = preserveMessageIds;
     }
   } catch (error) {
-    console.error("[PG Memory] Error handling session.compacting:", error);
+    logger5.error("Error handling session.compacting:", error);
   }
 }
 async function markCacheEntriesAsPruned(sessionId, messageIds, pool) {
@@ -12486,7 +12534,7 @@ async function markCacheEntriesAsPruned(sessionId, messageIds, pool) {
         WHERE id = ANY($2) AND tool_output_summary IS NOT NULL
       )
   `, [sessionId, observationIds]);
-  console.log(`[PG Memory] Marked ${result.rowCount} cache entries as pruned`);
+  logger5.info(`Marked ${result.rowCount} cache entries as pruned`);
 }
 async function determineMessagesToPreserve(sessionId, messagesToCompact, pool, config) {
   if (!config.preserveHighImportanceObservations) {
@@ -12503,10 +12551,11 @@ async function determineMessagesToPreserve(sessionId, messagesToCompact, pool, c
   return result.rows.map((row) => row.message_id);
 }
 async function handleSessionCompacted(input, output, pool, config = {}) {
-  console.log(`[PG Memory] Session compacted: ${input.session.id}`);
+  logger5.info(`Session compacted: ${input.session.id}`);
 }
 
 // src/hooks/session-completed.ts
+var logger6 = createLogger("session-completed");
 var DEFAULT_CONFIG5 = {
   reflectionThreshold: 30,
   minObservationThreshold: 30,
@@ -12517,23 +12566,23 @@ var DEFAULT_CONFIG5 = {
 async function handleSessionCompleted(input, output, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG5, ...config };
   const { session, summary } = input;
-  console.log(`[PG Memory] Session completed: ${session.id}, messages: ${session.messageCount}, duration: ${session.durationMs}ms`);
+  logger6.info(`Session completed: ${session.id}, messages: ${session.messageCount}, duration: ${session.durationMs}ms`);
   try {
-    const sessionResult = await pool.query("SELECT id, reflection_last_at FROM sessions WHERE external_id = $1", [session.id]);
+    const sessionResult = await pool.query("SELECT id, reflection_last_at FROM session_map WHERE opencode_session_id = $1", [session.id]);
     if (sessionResult.rows.length === 0) {
-      console.warn(`[PG Memory] Session not found: ${session.id}`);
+      logger6.warn(`Session not found: ${session.id}`);
       return;
     }
     const sessionInternalId = sessionResult.rows[0].id;
     const reflectionLastAt = sessionResult.rows[0].reflection_last_at;
     const observationStats = await getObservationStats(sessionInternalId, reflectionLastAt, pool);
-    console.log(`[PG Memory] Observations since last reflection: ${observationStats.countSinceLastReflection}`);
+    logger6.info(`Observations since last reflection: ${observationStats.countSinceLastReflection}`);
     const shouldReflect = await checkShouldTriggerReflection(sessionInternalId, observationStats.countSinceLastReflection, mergedConfig, pool);
     if (shouldReflect && mergedConfig.enableReflection) {
       await scheduleReflectionTask(sessionInternalId, session.id, observationStats.countSinceLastReflection, mergedConfig, pool);
     }
     await pool.query(`
-      UPDATE sessions 
+      UPDATE session_map 
       SET updated_at = NOW(),
           metadata = metadata || $1
       WHERE id = $2
@@ -12559,9 +12608,9 @@ async function handleSessionCompleted(input, output, pool, config = {}) {
         observationCount: observationStats.totalCount
       })
     ]);
-    console.log(`[PG Memory] Session completion processed: ${session.id}`);
+    logger6.info(`Session completion processed: ${session.id}`);
   } catch (error) {
-    console.error("[PG Memory] Error handling session.completed:", error);
+    logger6.error("Error handling session.completed:", error);
   }
 }
 async function getObservationStats(sessionId, reflectionLastAt, pool) {
@@ -12583,7 +12632,7 @@ async function checkShouldTriggerReflection(sessionId, observationCount, config,
     return false;
   }
   const threshold = Math.floor(Math.random() * (config.maxObservationThreshold - config.minObservationThreshold + 1)) + config.minObservationThreshold;
-  console.log(`[PG Memory] Reflection threshold: ${threshold}, current: ${observationCount}`);
+  logger6.info(`Reflection threshold: ${threshold}, current: ${observationCount}`);
   if (observationCount < threshold) {
     return false;
   }
@@ -12594,7 +12643,7 @@ async function checkShouldTriggerReflection(sessionId, observationCount, config,
   `, [sessionId]);
   const pendingCount = parseInt(pendingResult.rows[0].count, 10);
   if (pendingCount > 0) {
-    console.log(`[PG Memory] Reflection already in progress for session: ${sessionId}`);
+    logger6.info(`Reflection already in progress for session: ${sessionId}`);
     return false;
   }
   return true;
@@ -12602,7 +12651,7 @@ async function checkShouldTriggerReflection(sessionId, observationCount, config,
 async function scheduleReflectionTask(sessionInternalId, externalSessionId, observationCount, config, pool) {
   const currentHour = new Date().getHours();
   const isOffPeak = config.offPeakHours.includes(currentHour);
-  console.log(`[PG Memory] Scheduling reflection task for session: ${externalSessionId}, off-peak: ${isOffPeak}`);
+  logger6.info(`Scheduling reflection task for session: ${externalSessionId}, off-peak: ${isOffPeak}`);
   if (isOffPeak) {
     await executeReflection(sessionInternalId, externalSessionId, observationCount, pool);
   } else {
@@ -12610,7 +12659,7 @@ async function scheduleReflectionTask(sessionInternalId, externalSessionId, obse
   }
 }
 async function executeReflection(sessionId, externalSessionId, observationCount, pool) {
-  console.log(`[PG Memory] Executing reflection for session: ${externalSessionId}`);
+  logger6.info(`Executing reflection for session: ${externalSessionId}`);
   try {
     const observations = await pool.query(`
       SELECT id, tool_name, tool_input_summary, tool_output_summary, 
@@ -12621,7 +12670,7 @@ async function executeReflection(sessionId, externalSessionId, observationCount,
       LIMIT 100
     `, [sessionId]);
     if (observations.rows.length === 0) {
-      console.log(`[PG Memory] No observations to reflect on for session: ${externalSessionId}`);
+      logger6.info(`No observations to reflect on for session: ${externalSessionId}`);
       return;
     }
     const reflectionResult = await performReflection(observations.rows);
@@ -12647,13 +12696,13 @@ async function executeReflection(sessionId, externalSessionId, observationCount,
       }
     }
     await pool.query(`
-      UPDATE sessions 
+      UPDATE session_map 
       SET reflection_last_at = NOW()
       WHERE id = $1
     `, [sessionId]);
-    console.log(`[PG Memory] Reflection completed for session: ${externalSessionId}, patterns: ${reflectionResult.patterns.length}`);
+    logger6.info(`Reflection completed for session: ${externalSessionId}, patterns: ${reflectionResult.patterns.length}`);
   } catch (error) {
-    console.error(`[PG Memory] Reflection failed for session: ${externalSessionId}`, error);
+    logger6.error(`Reflection failed for session: ${externalSessionId}`, error);
     await pool.query(`
       INSERT INTO reflection_errors (
         session_id, error_message, error_stack,
@@ -12706,9 +12755,9 @@ async function performReflection(observations) {
   return { patterns };
 }
 async function queueReflectionForOffPeak(sessionId, externalSessionId, observationCount, pool) {
-  console.log(`[PG Memory] Queued reflection for off-peak execution: ${externalSessionId}`);
+  logger6.info(`Queued reflection for off-peak execution: ${externalSessionId}`);
   await pool.query(`
-    UPDATE sessions 
+    UPDATE session_map 
     SET metadata = metadata || $1
     WHERE id = $2
   `, [
@@ -18648,6 +18697,7 @@ function getEmbeddingService() {
 }
 
 // src/mcp/recall-memory.ts
+var logger7 = createLogger("recall-memory");
 var DEFAULT_CONFIG6 = {
   weights: {
     semantic: 0.5,
@@ -18662,7 +18712,7 @@ var PER_STRATEGY_LIMIT = 20;
 async function recallMemory(input, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG6, ...config };
   const startTime = Date.now();
-  console.log(`[PG Memory] recall_memory called: "${input.query.substring(0, 100)}..."`);
+  logger7.info(`recall_memory called: "${input.query.substring(0, 100)}..."`);
   try {
     const sessionId = await resolveSessionId(input, pool);
     const embeddingService = getEmbeddingService();
@@ -18678,7 +18728,7 @@ async function recallMemory(input, pool, config = {}) {
       if (fusionResult) {
         fusedEmbedding = fusionResult.fusedEmbedding;
         contextUsed = fusionResult.contextUsed;
-        console.log(`[PG Memory] Topic fusion applied (topic: ${fusionResult.contextUsed.topic_segment_id.substring(0, 8)}...)`);
+        logger7.info(`Topic fusion applied (topic: ${fusionResult.contextUsed.topic_segment_id.substring(0, 8)}...)`);
       }
     }
     const strategies = input.retrieval_strategies || ["semantic", "bm25", "graph"];
@@ -18717,7 +18767,7 @@ async function recallMemory(input, pool, config = {}) {
       };
     });
     const retrievalTime = Date.now() - startTime;
-    console.log(`[PG Memory] recall_memory completed: ${results.length} results in ${retrievalTime}ms`);
+    logger7.info(`recall_memory completed: ${results.length} results in ${retrievalTime}ms`);
     return {
       query: input.query,
       context_used: contextUsed,
@@ -18729,7 +18779,7 @@ async function recallMemory(input, pool, config = {}) {
       session_id: sessionId
     };
   } catch (error) {
-    console.error("[PG Memory] recall_memory error:", error);
+    logger7.error("recall_memory error:", error);
     const retrievalTime = Date.now() - startTime;
     return {
       query: input.query,
@@ -18756,13 +18806,13 @@ async function resolveSessionId(input, pool) {
   try {
     const recent = await pool.query("SELECT id, opencode_session_id FROM session_map ORDER BY last_active_at DESC LIMIT 1");
     if (recent.rows.length > 0) {
-      console.log(`[PG Memory] Auto-detected session: ${recent.rows[0].opencode_session_id}`);
+      logger7.info(`Auto-detected session: ${recent.rows[0].opencode_session_id}`);
       return recent.rows[0].id;
     }
   } catch {}
   const recentSession = await pool.query("SELECT id, external_id FROM sessions ORDER BY updated_at DESC NULLS LAST, created_at DESC LIMIT 1");
   if (recentSession.rows.length > 0) {
-    console.log(`[PG Memory] Auto-detected session (legacy): ${recentSession.rows[0].external_id}`);
+    logger7.info(`Auto-detected session (legacy): ${recentSession.rows[0].external_id}`);
     return recentSession.rows[0].id;
   }
   throw new Error("No session found. Please start a conversation first or provide session_id explicitly.");
@@ -18823,7 +18873,7 @@ async function topicContextFusion(externalSessionId, queryEmbedding, embeddingSe
       }
     };
   } catch (err) {
-    console.warn("[PG Memory] Topic context fusion skipped:", err);
+    logger7.warn("Topic context fusion skipped:", err);
     return null;
   }
 }
@@ -18852,7 +18902,7 @@ async function parallelRetrieve(query, queryEmbedding, sessionId, strategies, po
         const r2 = await semanticSearch(queryEmbedding, sessionId, pool, filterSQL);
         results.set("semantic", r2);
       } catch (err) {
-        console.warn("[PG Memory] Semantic search failed:", err);
+        logger7.warn("Semantic search failed:", err);
         results.set("semantic", []);
       }
     })());
@@ -18863,7 +18913,7 @@ async function parallelRetrieve(query, queryEmbedding, sessionId, strategies, po
         const r2 = await bm25Search(query, sessionId, pool, filterSQL);
         results.set("bm25", r2);
       } catch (err) {
-        console.warn("[PG Memory] BM25 search failed:", err);
+        logger7.warn("BM25 search failed:", err);
         results.set("bm25", []);
       }
     })());
@@ -18874,7 +18924,7 @@ async function parallelRetrieve(query, queryEmbedding, sessionId, strategies, po
         const r2 = await graphTraversal(query, embeddingServiceFallback(query), sessionId, pool, filterSQL);
         results.set("graph", r2);
       } catch (err) {
-        console.warn("[PG Memory] Graph traversal failed:", err);
+        logger7.warn("Graph traversal failed:", err);
         results.set("graph", []);
       }
     })());
@@ -18885,7 +18935,7 @@ async function parallelRetrieve(query, queryEmbedding, sessionId, strategies, po
         const r2 = await keywordSearch(query, sessionId, pool, filterSQL);
         results.set("keyword", r2);
       } catch (err) {
-        console.warn("[PG Memory] Keyword search failed:", err);
+        logger7.warn("Keyword search failed:", err);
         results.set("keyword", []);
       }
     })());
@@ -18950,7 +19000,7 @@ async function semanticSearch(queryEmbedding, sessionId, pool, filters) {
       _timestamp: row.created_at
     })));
   } catch (err) {
-    console.warn("[PG Memory] Entity semantic search error:", err);
+    logger7.warn("Entity semantic search error:", err);
   }
   try {
     const obsQuery = `
@@ -18984,7 +19034,7 @@ async function semanticSearch(queryEmbedding, sessionId, pool, filters) {
       _timestamp: row.created_at
     })));
   } catch (err) {
-    console.warn("[PG Memory] Observation semantic search error:", err);
+    logger7.warn("Observation semantic search error:", err);
   }
   try {
     const refQuery = `
@@ -19018,7 +19068,7 @@ async function semanticSearch(queryEmbedding, sessionId, pool, filters) {
       _timestamp: row.created_at
     })));
   } catch (err) {
-    console.warn("[PG Memory] Reflection semantic search error:", err);
+    logger7.warn("Reflection semantic search error:", err);
   }
   return facts;
 }
@@ -19064,7 +19114,7 @@ async function bm25Search(query, sessionId, pool, filters) {
       _timestamp: row.created_at
     })));
   } catch (err) {
-    console.warn("[PG Memory] BM25 search failed (pg_trgm may not be installed):", err);
+    logger7.warn("BM25 search failed (pg_trgm may not be installed):", err);
   }
   return facts;
 }
@@ -19126,7 +19176,7 @@ async function graphTraversal(query, _queryEmb, sessionId, pool, filters) {
       _timestamp: row.created_at
     }));
   } catch (err) {
-    console.warn("[PG Memory] Graph traversal error:", err);
+    logger7.warn("Graph traversal error:", err);
     return [];
   }
 }
@@ -19166,7 +19216,7 @@ async function keywordSearch(query, sessionId, pool, filters) {
       _timestamp: row.created_at
     }));
   } catch (err) {
-    console.warn("[PG Memory] Keyword search error:", err);
+    logger7.warn("Keyword search error:", err);
     return [];
   }
 }
@@ -19367,6 +19417,7 @@ function formatVectorLiteral(embedding) {
 }
 
 // src/mcp/hindsight-reflect.ts
+var logger8 = createLogger("hindsight-reflect");
 var DEFAULT_REFLECTION_SYSTEM_PROMPT = `You are a reflection engine that analyzes coding session observations to extract reusable patterns and insights.
 
 ## Task
@@ -19466,11 +19517,11 @@ async function hindsightReflect(input, pool, config = {}) {
   const mergedConfig = { ...DEFAULT_CONFIG7, ...config };
   const startTime = Date.now();
   let totalTokens = { input: 0, output: 0, total: 0 };
-  console.log(`[PG Memory] hindsight_reflect called: session=${input.session_id || "none"}, ` + `omo_task=${input.omo_task_id || "none"}, ` + `topic_segment=${input.topic_segment_id || "none"}, ` + `aggregate=${input.aggregate ?? false}`);
+  logger8.info(`hindsight_reflect called: session=${input.session_id || "none"}, ` + `omo_task=${input.omo_task_id || "none"}, ` + `topic_segment=${input.topic_segment_id || "none"}, ` + `aggregate=${input.aggregate ?? false}`);
   try {
     const scope = await resolveScope(input, pool);
     if (!scope.observable) {
-      console.log("[PG Memory] hindsight_reflect: no observations available for scope");
+      logger8.info("hindsight_reflect: no observations available for scope");
       return {
         generated_reflections: [],
         token_usage: totalTokens,
@@ -19479,17 +19530,17 @@ async function hindsightReflect(input, pool, config = {}) {
     }
     const observations = await collectObservations(input, scope, mergedConfig, pool);
     if (observations.length === 0) {
-      console.log("[PG Memory] hindsight_reflect: zero observations collected");
+      logger8.info("hindsight_reflect: zero observations collected");
       return {
         generated_reflections: [],
         token_usage: totalTokens,
         duration_ms: Date.now() - startTime
       };
     }
-    console.log(`[PG Memory] Fetched ${observations.length} observations for reflection`);
+    logger8.info(`Fetched ${observations.length} observations for reflection`);
     const threshold = mergedConfig.observationThreshold;
     if (observations.length < threshold && input.trigger_type !== "manual") {
-      console.log(`[PG Memory] hindsight_reflect: observation count (${observations.length}) ` + `below threshold (${threshold}), skipping`);
+      logger8.info(`hindsight_reflect: observation count (${observations.length}) ` + `below threshold (${threshold}), skipping`);
       return {
         generated_reflections: [],
         token_usage: totalTokens,
@@ -19498,7 +19549,7 @@ async function hindsightReflect(input, pool, config = {}) {
     }
     const shouldAggregate = input.aggregate === true || !!input.omo_task_id && input.aggregate !== false;
     const segments = groupObservationsBySegment(observations, shouldAggregate);
-    console.log(`[PG Memory] Grouped into ${segments.length} segment(s) ` + `(aggregate=${shouldAggregate})`);
+    logger8.info(`Grouped into ${segments.length} segment(s) ` + `(aggregate=${shouldAggregate})`);
     const generatedReflections = [];
     for (const segment of segments) {
       const segmentReflections = await reflectOnSegment(segment, scope, input, mergedConfig, pool);
@@ -19508,7 +19559,7 @@ async function hindsightReflect(input, pool, config = {}) {
     }
     await updateReflectionTimestamp(scope, pool);
     const elapsed = Date.now() - startTime;
-    console.log(`[PG Memory] hindsight_reflect completed: ` + `${generatedReflections.length} reflections in ${elapsed}ms`);
+    logger8.info(`hindsight_reflect completed: ` + `${generatedReflections.length} reflections in ${elapsed}ms`);
     return {
       generated_reflections: generatedReflections,
       token_usage: totalTokens,
@@ -19516,7 +19567,7 @@ async function hindsightReflect(input, pool, config = {}) {
     };
   } catch (error) {
     const elapsed = Date.now() - startTime;
-    console.error("[PG Memory] hindsight_reflect error:", error);
+    logger8.error("hindsight_reflect error:", error);
     await logReflectionError(input, error, pool);
     return {
       generated_reflections: [],
@@ -19582,21 +19633,21 @@ async function collectObservations(input, scope, config, pool) {
     try {
       return await collectObservationsForSegment(scope.topicSegmentId, config, pool);
     } catch (err) {
-      console.warn("[PG Memory] New-schema segment collection failed, falling back:", err);
+      logger8.warn("New-schema segment collection failed, falling back:", err);
     }
   }
   if (scope.omoTaskId && scope.usesNewSchema && scope.sessionMapIds.length > 0) {
     try {
       return await collectObservationsForOmoTask(scope.omoTaskId, config, pool);
     } catch (err) {
-      console.warn("[PG Memory] New-schema omo_task collection failed, falling back:", err);
+      logger8.warn("New-schema omo_task collection failed, falling back:", err);
     }
   }
   if (scope.usesNewSchema && scope.sessionMapIds.length > 0) {
     try {
       return await collectObservationsForSessionMaps(scope.sessionMapIds, config, pool);
     } catch (err) {
-      console.warn("[PG Memory] New-schema session_map collection failed, falling back:", err);
+      logger8.warn("New-schema session_map collection failed, falling back:", err);
     }
   }
   return collectObservationsLegacy(scope.sessionInternalIds, config, pool);
@@ -19744,7 +19795,7 @@ function buildReflectionPrompt(segment, batch, config, _input) {
   return template.replace("{topic_summary}", segment.topicSummary).replace("{session_context}", sessionContext).replace("{topics_summary}", segment.topicSummary).replace("{observations_json}", observationsJson);
 }
 async function performReflectionWithLLM(observations, topicSummary, config, prompt) {
-  console.log(`[PG Memory] Performing reflection with ${config.modelSize} model ` + `on ${observations.length} observations (topic: ${topicSummary})`);
+  logger8.info(`Performing reflection with ${config.modelSize} model ` + `on ${observations.length} observations (topic: ${topicSummary})`);
   return performHeuristicReflection(observations, topicSummary);
 }
 function performHeuristicReflection(observations, topicSummary) {
@@ -19852,7 +19903,7 @@ async function storeReflection(pattern, segment, scope, pool, config, input) {
           JSON.stringify(metadata)
         ]);
       } catch {
-        console.warn("[PG Memory] New schema INSERT failed, falling back to legacy");
+        logger8.warn("New schema INSERT failed, falling back to legacy");
       }
     }
     if (!insertResult && scope.sessionInternalIds.length > 0) {
@@ -19870,7 +19921,7 @@ async function storeReflection(pattern, segment, scope, pool, config, input) {
       ]);
     }
     if (!insertResult) {
-      console.warn("[PG Memory] No valid session reference to store reflection");
+      logger8.warn("No valid session reference to store reflection");
       return null;
     }
     return {
@@ -19885,7 +19936,7 @@ async function storeReflection(pattern, segment, scope, pool, config, input) {
       metadata
     };
   } catch (error) {
-    console.error("[PG Memory] Failed to store reflection:", error);
+    logger8.error("Failed to store reflection:", error);
     return null;
   }
 }
@@ -19909,7 +19960,7 @@ async function updateReflectionTimestamp(scope, pool) {
          WHERE id = $1`, [internalId]);
     }
   } catch (error) {
-    console.warn("[PG Memory] Failed to update reflection timestamp:", error);
+    logger8.warn("Failed to update reflection timestamp:", error);
   }
 }
 async function logReflectionError(input, error, pool) {
@@ -19928,7 +19979,7 @@ async function logReflectionError(input, error, pool) {
          observation_count, retry_count
        ) VALUES ($1, $2, $3, $4, $5)`, [sessionId, errorMessage, errorStack, 0, 0]);
   } catch (logError) {
-    console.error("[PG Memory] Failed to log reflection error:", logError);
+    logger8.error("Failed to log reflection error:", logError);
   }
 }
 async function tableExists(pool, tableName) {
@@ -20255,46 +20306,6 @@ function createCacheManager(pool, config) {
   return new SemanticCacheManager(pool, config);
 }
 
-// src/services/logger.ts
-var LEVEL_MAP = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var LEVEL_NAMES = {
-  debug: "DEBUG",
-  info: "INFO",
-  warn: "WARN",
-  error: "ERROR"
-};
-function getConfiguredLevel() {
-  const env = process.env.PG_MEMORY_LOG_LEVEL ?? "info";
-  const level = env.toLowerCase();
-  if (level in LEVEL_MAP) {
-    return LEVEL_MAP[level];
-  }
-  return LEVEL_MAP.info;
-}
-var currentLevel = getConfiguredLevel();
-function log(level, module, msg, data) {
-  if (currentLevel > LEVEL_MAP[level]) {
-    return;
-  }
-  const line = data !== undefined ? `[PG Memory] [${LEVEL_NAMES[level]}] [${module}] ${msg} ${JSON.stringify(data)}
-` : `[PG Memory] [${LEVEL_NAMES[level]}] [${module}] ${msg}
-`;
-  process.stderr.write(line);
-}
-function createLogger(module) {
-  return {
-    debug: (msg, data) => log("debug", module, msg, data),
-    info: (msg, data) => log("info", module, msg, data),
-    warn: (msg, data) => log("warn", module, msg, data),
-    error: (msg, data) => log("error", module, msg, data)
-  };
-}
-
 // src/services/keyword.ts
 var CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
 var INLINE_CODE_PATTERN = /`[^`]+`/g;
@@ -20332,6 +20343,7 @@ Consider using the following tools to persist this knowledge:
 - The pg-memory plugin will automatically record this session's observations for future use.`;
 
 // src/index.ts
+var logger9 = createLogger("plugin");
 var DEFAULT_PLUGIN_CONFIG = {
   database: {
     host: process.env.PG_HOST || "localhost",
@@ -20401,7 +20413,7 @@ class OpenCodePGMemoryPlugin {
   async initialize() {
     if (this.initialized)
       return;
-    console.log("[PG Memory] Initializing plugin...");
+    logger9.info("Initializing plugin...");
     try {
       this.pool = await initializeDatabase(this.config.database);
       if (this.config.cache.enabled) {
@@ -20409,16 +20421,16 @@ class OpenCodePGMemoryPlugin {
       }
       this.startCleanupTasks();
       this.initialized = true;
-      console.log("[PG Memory] Plugin initialized successfully");
+      logger9.info("Plugin initialized successfully");
     } catch (error) {
-      console.error("[PG Memory] Plugin initialization failed:", error);
+      logger9.error("Plugin initialization failed:", error);
       throw error;
     }
   }
   async close() {
     if (!this.initialized)
       return;
-    console.log("[PG Memory] Closing plugin...");
+    logger9.info("Closing plugin...");
     for (const interval of this.cleanupIntervals) {
       clearInterval(interval);
     }
@@ -20427,7 +20439,7 @@ class OpenCodePGMemoryPlugin {
     this.pool = null;
     this.cacheManager = null;
     this.initialized = false;
-    console.log("[PG Memory] Plugin closed");
+    logger9.info("Plugin closed");
   }
   startCleanupTasks() {
     this.cleanupIntervals.push(setInterval(() => {
@@ -20454,14 +20466,13 @@ var OpenCodePGMemory = async (ctx) => {
   const plugin = new OpenCodePGMemoryPlugin(config);
   await plugin.initialize();
   const cleanup = () => {
-    plugin.close().catch((err) => console.error("[PG Memory] Cleanup error:", err));
+    plugin.close().catch((err) => logger9.error("Cleanup error:", err));
   };
   process.on("exit", cleanup);
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   const pool = plugin.getPool();
   const cacheManager = plugin.getCacheManager();
-  const logger = createLogger("plugin");
   const injectedSessions = new Set;
   const injectedSystemPrompt = new Set;
   return {
@@ -20483,7 +20494,7 @@ var OpenCodePGMemory = async (ctx) => {
                   await ctx.client.experimental.chat.system.transform(memory);
                 }
               } catch (err) {
-                console.warn("[PG Memory] Failed to inject memories via client:", err);
+                logger9.warn("Failed to inject memories via client:", err);
               }
             }
             break;
@@ -20498,18 +20509,18 @@ var OpenCodePGMemory = async (ctx) => {
               }, {}, pool);
               if (cacheManager && properties.messagesToCompact?.length) {
                 try {
-                  const obsResult = await pool.query("SELECT id FROM observations WHERE session_id = (SELECT id FROM sessions WHERE external_id = $1) AND message_id = ANY($2)", [sid, properties.messagesToCompact]);
+                  const obsResult = await pool.query("SELECT id FROM observations WHERE session_id = (SELECT id FROM session_map WHERE opencode_session_id = $1) AND message_id = ANY($2)", [sid, properties.messagesToCompact]);
                   if (obsResult.rows.length > 0) {
                     await cacheManager.markMultipleAsPruned(obsResult.rows.map((r2) => r2.id));
                   }
                 } catch (err) {
-                  console.warn("[PG Memory] Failed to mark cache pruned:", err);
+                  logger9.warn("Failed to mark cache pruned:", err);
                 }
               }
               const summaryText = properties.summary || properties.compactionSummary;
               if (summaryText && String(summaryText).length >= 100) {
                 try {
-                  const sessionResult = await pool.query("SELECT id FROM sessions WHERE external_id = $1", [sid]);
+                  const sessionResult = await pool.query("SELECT id FROM session_map WHERE opencode_session_id = $1", [sid]);
                   if (sessionResult.rows.length > 0) {
                     await pool.query(`
                       INSERT INTO reflections (session_id, summary, source_observation_ids, confidence, pattern_type, metadata)
@@ -20522,10 +20533,10 @@ var OpenCodePGMemory = async (ctx) => {
                       "session_summary",
                       JSON.stringify({ savedAt: new Date().toISOString() })
                     ]);
-                    logger.info("Saved session summary as reflection", { sessionID: sid });
+                    logger9.info("Saved session summary as reflection", { sessionID: sid });
                   }
                 } catch (err) {
-                  logger.warn("Failed to save session summary", err);
+                  logger9.warn("Failed to save session summary", err);
                 }
               }
             }
@@ -20535,14 +20546,14 @@ var OpenCodePGMemory = async (ctx) => {
             const sid = properties.sessionID || properties.session?.id;
             if (sid) {
               try {
-                const sessionResult = await pool.query("SELECT id FROM sessions WHERE external_id = $1", [sid]);
+                const sessionResult = await pool.query("SELECT id FROM session_map WHERE opencode_session_id = $1", [sid]);
                 if (sessionResult.rows.length > 0) {
                   const internalId = sessionResult.rows[0].id;
-                  await pool.query("DELETE FROM sessions WHERE id = $1", [internalId]);
-                  console.log(`[PG Memory] Cleaned up deleted session: ${sid}`);
+                  await pool.query("DELETE FROM session_map WHERE id = $1", [internalId]);
+                  logger9.info(`Cleaned up deleted session: ${sid}`);
                 }
               } catch (err) {
-                console.error("[PG Memory] Error cleaning up deleted session:", err);
+                logger9.error("Error cleaning up deleted session:", err);
               }
             }
             break;
@@ -20571,7 +20582,7 @@ var OpenCodePGMemory = async (ctx) => {
           case "message.updated": {
             const sid = properties.sessionID || properties.session?.id;
             if (sid && properties.message) {
-              handleMessageUpdated({ session: { id: sid }, message: properties.message }, {}, pool).catch((err) => console.warn("[PG Memory] message.updated handler error:", err));
+              handleMessageUpdated({ session: { id: sid }, message: properties.message }, {}, pool).catch((err) => logger9.warn("message.updated handler error:", err));
             }
             break;
           }
@@ -20603,14 +20614,14 @@ var OpenCodePGMemory = async (ctx) => {
             break;
         }
       } catch (error) {
-        console.error(`[PG Memory] Error handling event '${type}':`, error);
+        logger9.error(`Error handling event '${type}':`, error);
       }
     },
     "chat.message": async (input, output) => {
       try {
         if (!injectedSessions.has(input.sessionID)) {
           injectedSessions.add(input.sessionID);
-          logger.info("First message in session", { sessionID: input.sessionID });
+          logger9.info("First message in session", { sessionID: input.sessionID });
           const contextLimit = 128000;
           const budget = calculateTokenBudget(contextLimit, config.tokenBudget || {});
           const facts = await retrieveFactsForInjection2(input.sessionID, { maxTokens: typeof budget === "number" ? budget : 2000 }, pool, { minConfidence: 0.5, minWeight: 0.3 });
@@ -20625,15 +20636,15 @@ var OpenCodePGMemory = async (ctx) => {
                 text: contextBlock,
                 synthetic: true
               });
-              logger.info(`Injected ${facts.length} memories`, { sessionID: input.sessionID });
+              logger9.info(`Injected ${facts.length} memories`, { sessionID: input.sessionID });
             }
           } else {
-            logger.debug("No memories to inject");
+            logger9.debug("No memories to inject");
           }
         }
         const userText = output.parts.filter((p2) => p2.type === "text" && !p2.synthetic).map((p2) => p2.text || "").join(" ");
         if (detectMemoryKeyword(userText)) {
-          logger.info("Memory keyword detected", { sessionID: input.sessionID });
+          logger9.info("Memory keyword detected", { sessionID: input.sessionID });
           output.parts.push({
             id: `prt_pgmemory-nudge-${Date.now()}`,
             sessionID: input.sessionID,
@@ -20644,7 +20655,7 @@ var OpenCodePGMemory = async (ctx) => {
           });
         }
       } catch (error) {
-        logger.error("Failed to inject memories in chat.message", error);
+        logger9.error("Failed to inject memories in chat.message", error);
       }
     },
     "tool.execute.before": async (input, output) => {
@@ -20655,7 +20666,7 @@ var OpenCodePGMemory = async (ctx) => {
           messageId: input.callID
         }, { parameters: output.args }, pool);
       } catch (error) {
-        console.error("[PG Memory] Error in tool.execute.before:", error);
+        logger9.error("Error in tool.execute.before:", error);
       }
     },
     "tool.execute.after": async (input, output) => {
@@ -20673,7 +20684,7 @@ var OpenCodePGMemory = async (ctx) => {
           executionTimeMs: output.metadata?.executionTimeMs || 0
         }, {}, pool);
       } catch (error) {
-        console.error("[PG Memory] Error in tool.execute.after:", error);
+        logger9.error("Error in tool.execute.after:", error);
       }
     },
     "experimental.chat.system.transform": async (input, output) => {
@@ -20703,7 +20714,7 @@ Call this AFTER completing significant work to extract reusable patterns.
 - When you need historical context about a specific topic → recall_memory(topic_segment_id=<id>)
 `);
       } catch (error) {
-        console.error("[PG Memory] Error in system.transform:", error);
+        logger9.error("Error in system.transform:", error);
       }
     },
     "experimental.session.compacting": async (input, output) => {
@@ -20736,7 +20747,7 @@ Call this AFTER completing significant work to extract reusable patterns.
           }, 500);
         }
       } catch (error) {
-        console.error("[PG Memory] Error in experimental.session.compacting:", error);
+        logger9.error("Error in experimental.session.compacting:", error);
       }
     },
     tool: {