nexus-agents 8.42.0 → 8.42.2

package/dist/{chunk-7FA6RW5Z.js → chunk-KOC6XT7R.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-7LP6VJRP.js";
 import {
   SessionMemory
-} from "./chunk-YSR3YBI3.js";
+} from "./chunk-JMFEI2VQ.js";
 import {
   StatsOnlyAdapter,
   ensureSharedMemoryRegistry
@@ -15,7 +15,7 @@ import {
 } from "./chunk-YYJFZ7TO.js";
 import {
   generateId
-} from "./chunk-L5DQZ2G6.js";
+} from "./chunk-VIXTMS4E.js";
 import {
   ErrorCode,
   NexusError,
@@ -29,7 +29,7 @@ import {
   ok,
   openSqliteDatabase,
   setSharedMobiMemDbPathResolver
-} from "./chunk-E7HUVU7E.js";
+} from "./chunk-Z7POHKXD.js";
 import {
   nexusDataPath
 } from "./chunk-JVNJJ2VL.js";
@@ -719,13 +719,13 @@ var HindsightBeliefMemory = class {
   domainIndex = /* @__PURE__ */ new Map();
   config;
   logger;
-  constructor(config, logger7) {
+  constructor(config, logger8) {
     const validation = BeliefMemoryConfigSchema.safeParse(config ?? {});
     if (!validation.success) {
       throw new MemoryError(`Invalid BeliefMemoryConfig: ${formatZodError(validation.error)}`);
     }
     this.config = { ...DEFAULT_BELIEF_CONFIG, ...config };
-    this.logger = logger7 ?? createLogger({ component: "HindsightBeliefMemory" });
+    this.logger = logger8 ?? createLogger({ component: "HindsightBeliefMemory" });
     this.logger.info("HindsightBeliefMemory initialized", { config: this.config });
   }
   get auditStores() {
@@ -1192,9 +1192,9 @@ import { z as z6 } from "zod";
 import * as fs from "node:fs";
 import * as path from "node:path";
 var MemoryMarkdownHelper = class {
-  constructor(markdownDir, logger7) {
+  constructor(markdownDir, logger8) {
     this.markdownDir = markdownDir;
-    this.logger = logger7;
+    this.logger = logger8;
   }
   markdownDir;
   logger;
@@ -1334,7 +1334,7 @@ function rowToEntry(row) {
 function sanitizeFtsQuery(query) {
   return query.replace(/[*:^"(){}[\]]/g, " ").replace(/\bAND\b/gi, " ").replace(/\bOR\b/gi, " ").replace(/\bNOT\b/gi, " ").replace(/\bNEAR\b/gi, " ").replace(/\s+/g, " ").trim();
 }
-function cleanupExpiredEntries(rows, database, autoExpire, logger7) {
+function cleanupExpiredEntries(rows, database, autoExpire, logger8) {
   const now = getTimeProvider().now();
   const entries = [];
   const expiredKeys = [];
@@ -1350,7 +1350,7 @@ function cleanupExpiredEntries(rows, database, autoExpire, logger7) {
       `DELETE FROM memories WHERE key IN (${expiredKeys.map(() => "?").join(",")})`
     );
     deleteStmt.run(...expiredKeys);
-    logger7.debug("Auto-expired memories", { count: expiredKeys.length });
+    logger8.debug("Auto-expired memories", { count: expiredKeys.length });
   }
   return { entries, expiredCount: expiredKeys.length };
 }
@@ -1364,24 +1364,24 @@ function countMemories(database) {
     return err(new MemoryError("Failed to count memories", { cause: causeError }));
   }
 }
-function expireAllEntries(database, logger7) {
+function expireAllEntries(database, logger8) {
   try {
     const stmt = database.prepare(
       "DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?"
     );
     const result = stmt.run(getTimeProvider().now());
-    logger7.info("Expired memories", { count: result.changes });
+    logger8.info("Expired memories", { count: result.changes });
     return ok(result.changes);
   } catch (error) {
     const causeError = error instanceof Error ? error : new Error(String(error));
     return err(new MemoryError("Failed to expire memories", { cause: causeError }));
   }
 }
-function pruneOldEntries(database, olderThan, logger7) {
+function pruneOldEntries(database, olderThan, logger8) {
   try {
     const stmt = database.prepare("DELETE FROM memories WHERE created_at < ?");
     const result = stmt.run(olderThan.getTime());
-    logger7.info("Pruned old memories", {
+    logger8.info("Pruned old memories", {
       olderThan: olderThan.toISOString(),
       count: result.changes
     });
@@ -1738,18 +1738,51 @@ function safeJsonParse(json, fallback, context) {
     return fallback;
   }
 }
+function parseMetadata(row) {
+  let raw;
+  try {
+    raw = JSON.parse(row.metadata);
+  } catch (error) {
+    return err({
+      key: row.key,
+      reason: "metadata_not_json",
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const parsed = MemoryMetadataSchema.loose().safeParse(raw);
+  if (!parsed.success) {
+    return err({
+      key: row.key,
+      reason: "metadata_wrong_shape",
+      detail: parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ")
+    });
+  }
+  const { importance, tags, ttl, ...rest } = parsed.data;
+  const metadata = {
+    ...rest,
+    importance,
+    ...tags !== void 0 && { tags },
+    ...ttl !== void 0 && { ttl }
+  };
+  return ok(metadata);
+}
 function memoryRowToEntry(row) {
-  return {
+  const metadata = parseMetadata(row);
+  if (!metadata.ok) {
+    logger.warn("Unreadable metadata in memory database row", {
+      key: row.key,
+      reason: metadata.error.reason,
+      detail: metadata.error.detail
+    });
+    return metadata;
+  }
+  return ok({
     key: row.key,
     value: safeJsonParse(row.value, row.value, `value for key="${row.key}"`),
-    metadata: safeJsonParse(
-      row.metadata,
-      { importance: MemoryImportance.MEDIUM },
-      `metadata for key="${row.key}"`
-    ),
+    metadata: metadata.value,
     createdAt: new Date(row.created_at),
     accessedAt: new Date(row.accessed_at)
-  };
+  });
 }
 function memoryExists(db, key) {
   const stmt = db.prepare(
@@ -1761,7 +1794,10 @@ function memoryExists(db, key) {
 function getMemoryEntry(db, key) {
   const stmt = db.prepare("SELECT * FROM memories WHERE key = ?");
   const row = stmt.get(key);
-  return row !== void 0 ? memoryRowToEntry(row) : void 0;
+  if (row === void 0) return err({ kind: "not_found", key });
+  const entry = memoryRowToEntry(row);
+  if (!entry.ok) return err({ kind: "unreadable", unreadable: entry.error });
+  return entry;
 }
 function getMemoryRow(db, key) {
   const stmt = db.prepare("SELECT * FROM memories WHERE key = ?");
@@ -1773,6 +1809,7 @@ function getAllMemoryRows(db, limit) {
 }
 
 // src/context/graph-memory-helpers.ts
+var logger2 = createLogger({ component: "GraphMemoryHelpers" });
 var CREATE_EDGES_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS graph_edges (
     from_key TEXT NOT NULL,
@@ -1866,6 +1903,21 @@ function buildTraversalResult(entry, depth, path4, edge) {
   }
   return { entry, depth, path: path4 };
 }
+function lookUpVisitedNode(db, current) {
+  const looked = getMemoryEntry(db, current.key);
+  if (looked.ok) {
+    return buildTraversalResult(looked.value, current.depth, current.path, current.edge);
+  }
+  noteSkippedNode(current.key, looked.error);
+  return void 0;
+}
+function noteSkippedNode(key, failure) {
+  if (failure.kind !== "unreadable") return;
+  logger2.warn("Graph traversal skipped a node with unreadable metadata", {
+    key,
+    reason: failure.unreadable.reason
+  });
+}
 function bfsTraverse(config) {
   const { db, startKey, opts } = config;
   const state = {
@@ -1877,10 +1929,8 @@ function bfsTraverse(config) {
     const current = state.queue.shift();
     if (current === void 0) break;
     if (current.depth > 0 || opts.includeStart) {
-      const entry = getMemoryEntry(db, current.key);
-      if (entry !== void 0) {
-        state.results.push(buildTraversalResult(entry, current.depth, current.path, current.edge));
-      }
+      const result = lookUpVisitedNode(db, current);
+      if (result !== void 0) state.results.push(result);
     }
     if (current.depth >= opts.maxDepth) continue;
     const edges = getEdgesForKey({ db, key: current.key, direction: opts.direction });
@@ -1920,7 +1970,7 @@ function findShortestPath(db, from, to, opts) {
 }
 
 // src/context/graph-memory.ts
-var logger2 = createLogger({ component: "GraphMemoryBackend" });
+var logger3 = createLogger({ component: "GraphMemoryBackend" });
 var GraphMemoryBackend = class {
   config;
   log;
@@ -1935,7 +1985,7 @@ var GraphMemoryBackend = class {
       throw new MemoryError(`Invalid GraphMemoryBackend config: ${msg}`);
     }
     this.config = { ...DEFAULT_GRAPH_MEMORY_CONFIG, ...config };
-    this.log = logger2;
+    this.log = logger3;
     this.base = new HybridMemoryBackend({ dbPath: config.dbPath, markdownDir: config.markdownDir });
   }
   async initialize() {
@@ -2431,7 +2481,7 @@ function mergeLinkingConfig(partial) {
 }
 
 // src/context/agentic-memory-db-helpers.ts
-var logger3 = createLogger({ component: "AgenticMemoryDbHelpers" });
+var logger4 = createLogger({ component: "AgenticMemoryDbHelpers" });
 function safeExtractAttributes(amem) {
   if (!Array.isArray(amem.keywords) || amem.attributesUpdatedAt === void 0) return null;
   const updatedAt = amem.attributesUpdatedAt;
@@ -2451,17 +2501,36 @@ function parseAmemAttributes(metadata) {
   return safeExtractAttributes(meta.amem);
 }
 function memoryRowToAgenticEntry(row, extractionConfig) {
-  const baseEntry = memoryRowToEntry(row);
+  const converted = memoryRowToEntry(row);
+  if (!converted.ok) return converted;
+  const baseEntry = converted.value;
   let parsedMeta = {};
   try {
     parsedMeta = JSON.parse(row.metadata);
   } catch {
-    logger3.warn("Corrupt metadata JSON in memory row, using fallback extraction", {
+    logger4.warn("Corrupt metadata JSON in memory row, using fallback extraction", {
       key: row.key
     });
   }
   const attributes = parseAmemAttributes(parsedMeta) ?? extractAttributes(baseEntry.value, extractionConfig);
-  return { ...baseEntry, attributes };
+  return ok({ ...baseEntry, attributes });
+}
+function collectReadable(rows, extractionConfig, context) {
+  const entries = [];
+  const skipped = [];
+  for (const row of rows) {
+    const converted = memoryRowToAgenticEntry(row, extractionConfig);
+    if (converted.ok) entries.push(converted.value);
+    else skipped.push(converted.error.key);
+  }
+  if (skipped.length > 0) {
+    logger4.warn("Skipped memory rows with unreadable metadata", {
+      context,
+      skipped: skipped.length,
+      keys: skipped
+    });
+  }
+  return entries;
 }
 function searchWithAttributes(db, query, limit, extractionConfig) {
   const sanitized = query.replace(/[*()":^]/g, "").replace(/\s+/g, " ").trim();
@@ -2472,7 +2541,7 @@ function searchWithAttributes(db, query, limit, extractionConfig) {
     WHERE memories_fts MATCH ? ORDER BY rank LIMIT ?
   `);
   const rows = stmt.all(sanitized, limit);
-  return rows.map((row) => memoryRowToAgenticEntry(row, extractionConfig));
+  return collectReadable(rows, extractionConfig, "searchWithAttributes");
 }
 function getAttributeSet(attrs, type) {
   switch (type) {
@@ -2489,7 +2558,7 @@ function getAttributesFromRow(row, extractionConfig) {
   try {
     meta = JSON.parse(row.metadata);
   } catch {
-    logger3.warn("Corrupt metadata JSON in getAttributesFromRow, using value extraction", {
+    logger4.warn("Corrupt metadata JSON in getAttributesFromRow, using value extraction", {
       key: row.key
     });
   }
@@ -2501,7 +2570,7 @@ function getAttributesFromRow(row, extractionConfig) {
   try {
     parsedValue = JSON.parse(row.value);
   } catch {
-    logger3.warn("Corrupt value JSON in getAttributesFromRow, using raw string", {
+    logger4.warn("Corrupt value JSON in getAttributesFromRow, using raw string", {
       key: row.key
     });
   }
@@ -2509,13 +2578,26 @@ function getAttributesFromRow(row, extractionConfig) {
 }
 function findMatchingMemories(rows, sourceSet, attributeType, extractionConfig) {
   const matches = [];
+  const skipped = [];
   for (const row of rows) {
     const attrs = getAttributesFromRow(row, extractionConfig);
     const targetSet = getAttributeSet(attrs, attributeType);
     let overlap = 0;
     for (const item of sourceSet) if (targetSet.has(item)) overlap++;
-    if (overlap > 0)
-      matches.push({ entry: memoryRowToAgenticEntry(row, extractionConfig), overlap });
+    if (overlap === 0) continue;
+    const converted = memoryRowToAgenticEntry(row, extractionConfig);
+    if (!converted.ok) {
+      skipped.push(converted.error.key);
+      continue;
+    }
+    matches.push({ entry: converted.value, overlap });
+  }
+  if (skipped.length > 0) {
+    logger4.warn("Skipped memory rows with unreadable metadata", {
+      context: "findMatchingMemories",
+      skipped: skipped.length,
+      keys: skipped
+    });
   }
   matches.sort((a, b) => b.overlap - a.overlap);
   return matches;
@@ -2591,7 +2673,7 @@ function buildAgenticEntry(key, value, metadata, attributes, createdAt) {
 }
 
 // src/context/agentic-memory.ts
-var logger4 = createLogger({ component: "AgenticMemoryBackend" });
+var logger5 = createLogger({ component: "AgenticMemoryBackend" });
 var AgenticMemoryBackend = class {
   config;
   log;
@@ -2609,7 +2691,7 @@ var AgenticMemoryBackend = class {
       throw new MemoryError(`Invalid AgenticMemoryBackend config: ${msg}`);
     }
     this.config = config;
-    this.log = logger4;
+    this.log = logger5;
     this.extractionConfig = mergeExtractionConfig(config.extraction);
     this.linkingConfig = mergeLinkingConfig(config.linking);
     this.base = new HybridMemoryBackend({
@@ -2706,8 +2788,17 @@ var AgenticMemoryBackend = class {
       this.ensureInit();
       const row = queryMemoryByKey(this.getDb(), key);
       if (row === void 0) return Promise.resolve(ok(null));
-      const entry = memoryRowToAgenticEntry(row, this.extractionConfig);
-      return Promise.resolve(ok(entry));
+      const converted = memoryRowToAgenticEntry(row, this.extractionConfig);
+      if (!converted.ok) {
+        return Promise.resolve(
+          err(
+            new MemoryError(`Unreadable metadata for key: ${key}`, {
+              context: { reason: converted.error.reason, detail: converted.error.detail }
+            })
+          )
+        );
+      }
+      return Promise.resolve(ok(converted.value));
     } catch (error) {
       const cause = error instanceof Error ? error : new Error(String(error));
       return Promise.resolve(err(new MemoryError("Failed to retrieve with attributes", { cause })));
@@ -3057,10 +3148,17 @@ function touchMemory(db, key) {
   const result = stmt.run(getTimeProvider().now(), key);
   return result.changes > 0;
 }
-function scoreAndSortEntries(rows, opts, config) {
+function scoreRows(rows, opts, config) {
   const now = new Date(getTimeProvider().now());
-  const scored = rows.map((row) => {
-    const entry = memoryRowToEntry(row);
+  const scored = [];
+  const unreadable = [];
+  for (const row of rows) {
+    const converted = memoryRowToEntry(row);
+    if (!converted.ok) {
+      unreadable.push(converted.error);
+      continue;
+    }
+    const entry = converted.value;
     const priority = calculatePriorityScore({
       entry,
       now,
@@ -3068,8 +3166,12 @@ function scoreAndSortEntries(rows, opts, config) {
       ...opts?.query !== void 0 && { query: opts.query },
       ...opts?.weights !== void 0 && { weightOverrides: opts.weights }
     });
-    return { entry, priority };
-  });
+    scored.push({ entry, priority });
+  }
+  return { scored, unreadable };
+}
+function scoreAndSortEntries(rows, opts, config) {
+  const { scored, unreadable } = scoreRows(rows, opts, config);
   const filterConfig = {
     ...opts?.minScore !== void 0 && { minScore: opts.minScore },
     ...opts?.importanceFilter !== void 0 && { importanceFilter: opts.importanceFilter },
@@ -3078,7 +3180,7 @@ function scoreAndSortEntries(rows, opts, config) {
   const filtered = filterScoredEntries(scored, filterConfig);
   filtered.sort((a, b) => b.priority.score - a.priority.score);
   const limit = opts?.limit ?? 100;
-  return filtered.slice(0, limit);
+  return { entries: filtered.slice(0, limit), unreadable };
 }
 function mergeScoringConfig(partial) {
   if (partial === void 0) return DEFAULT_SCORING_CONFIG;
@@ -3090,7 +3192,7 @@ function mergeScoringConfig(partial) {
 }
 
 // src/context/adaptive-memory.ts
-var logger5 = createLogger({ component: "AdaptiveMemoryBackend" });
+var logger6 = createLogger({ component: "AdaptiveMemoryBackend" });
 var AdaptiveMemoryBackend = class {
   config;
   log;
@@ -3106,7 +3208,7 @@ var AdaptiveMemoryBackend = class {
       throw new MemoryError(`Invalid AdaptiveMemoryBackend config: ${msg}`);
     }
     this.config = config;
-    this.log = logger5;
+    this.log = logger6;
     this.scoringConfig = mergeScoringConfig(config.scoring);
     this.base = new HybridMemoryBackend({ dbPath: config.dbPath, markdownDir: config.markdownDir });
   }
@@ -3171,8 +3273,18 @@ var AdaptiveMemoryBackend = class {
       const maxFetch = (opts?.limit ?? 100) * 2;
       const rows = getAllMemoryRows(db, maxFetch);
       const scored = scoreAndSortEntries(rows, opts, this.scoringConfig);
-      this.log.debug("Retrieved by priority", { count: scored.length, query: opts?.query });
-      return Promise.resolve(ok(scored));
+      if (scored.unreadable.length > 0) {
+        this.log.warn("Skipped memory rows with unreadable metadata", {
+          skipped: scored.unreadable.length,
+          keys: scored.unreadable.map((u) => u.key)
+        });
+      }
+      this.log.debug("Retrieved by priority", {
+        count: scored.entries.length,
+        skipped: scored.unreadable.length,
+        query: opts?.query
+      });
+      return Promise.resolve(ok(scored.entries));
     } catch (error) {
       const cause = error instanceof Error ? error : new Error(String(error));
       return Promise.resolve(err(new MemoryError("Failed to retrieve by priority", { cause })));
@@ -3189,9 +3301,18 @@ var AdaptiveMemoryBackend = class {
       if (row === void 0) {
         return Promise.resolve(err(new MemoryError(`Key not found: ${key}`)));
       }
-      const entry = memoryRowToEntry(row);
+      const converted = memoryRowToEntry(row);
+      if (!converted.ok) {
+        return Promise.resolve(
+          err(
+            new MemoryError(`Unreadable metadata for key: ${key}`, {
+              context: { reason: converted.error.reason, detail: converted.error.detail }
+            })
+          )
+        );
+      }
       const priority = calculatePriorityScore({
-        entry,
+        entry: converted.value,
         now: new Date(getTimeProvider().now()),
         config: this.scoringConfig,
         ...query !== void 0 && { query }
@@ -3510,23 +3631,23 @@ function getSnapshotFiles() {
     return [];
   }
 }
-function enforceRetention(logger7) {
+function enforceRetention(logger8) {
   try {
     const files = getSnapshotFiles();
     if (files.length <= MAX_SNAPSHOT_FILES) return;
     const toDelete = files.slice(MAX_SNAPSHOT_FILES);
     for (const file of toDelete) fs2.unlinkSync(path2.join(getBeliefsDir(), file));
-    logger7.debug("Belief snapshot retention enforced", {
+    logger8.debug("Belief snapshot retention enforced", {
       kept: MAX_SNAPSHOT_FILES,
       deleted: toDelete.length
     });
   } catch (error) {
-    logger7.debug("Belief snapshot retention cleanup failed", {
+    logger8.debug("Belief snapshot retention cleanup failed", {
       error: getErrorMessage(error)
     });
   }
 }
-function saveBeliefSnapshot(data, logger7) {
+function saveBeliefSnapshot(data, logger8) {
   try {
     ensureBeliefsDir();
     const snapshot = createSnapshot(data);
@@ -3534,20 +3655,20 @@ function saveBeliefSnapshot(data, logger7) {
     const filename = `beliefs-${timestamp}.json`;
     const filepath = path2.join(getBeliefsDir(), filename);
     fs2.writeFileSync(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
-    logger7.info("Belief memory snapshot saved", { filename, beliefs: snapshot.beliefs.length });
-    enforceRetention(logger7);
+    logger8.info("Belief memory snapshot saved", { filename, beliefs: snapshot.beliefs.length });
+    enforceRetention(logger8);
     return ok(filepath);
   } catch (error) {
     const message = getErrorMessage(error);
     return err(new Error(`Failed to save belief snapshot: ${message}`));
   }
 }
-function loadBeliefSnapshot(logger7) {
+function loadBeliefSnapshot(logger8) {
   try {
     ensureBeliefsDir();
     const files = getSnapshotFiles();
     if (files.length === 0) {
-      logger7.debug("No belief snapshots found");
+      logger8.debug("No belief snapshots found");
       return ok(null);
     }
     for (const file of files.slice(0, 3)) {
@@ -3556,20 +3677,20 @@ function loadBeliefSnapshot(logger7) {
         const raw = JSON.parse(fs2.readFileSync(filepath, "utf-8"));
         const validation = BeliefSnapshotSchema.safeParse(raw);
         if (!validation.success) {
-          logger7.warn("Invalid belief snapshot file", { file, errors: validation.error.issues });
+          logger8.warn("Invalid belief snapshot file", { file, errors: validation.error.issues });
           continue;
         }
         const hydrated = hydrateSnapshot(validation.data);
-        logger7.info("Belief memory snapshot loaded", { file, beliefs: hydrated.beliefs.size });
+        logger8.info("Belief memory snapshot loaded", { file, beliefs: hydrated.beliefs.size });
         return ok(hydrated);
       } catch (error) {
-        logger7.warn("Failed to load belief snapshot file", {
+        logger8.warn("Failed to load belief snapshot file", {
           file,
           error: getErrorMessage(error)
         });
       }
     }
-    logger7.warn("All recent belief snapshots are invalid");
+    logger8.warn("All recent belief snapshots are invalid");
     return ok(null);
   } catch (error) {
     const message = getErrorMessage(error);
@@ -3971,7 +4092,7 @@ var KnowledgeVaultImpl = class {
 };
 
 // src/context/typed-memory.ts
-var logger6 = createLogger({ component: "typed-memory" });
+var logger7 = createLogger({ component: "typed-memory" });
 var STATS_SEARCH_CAP = 1e3;
 var TypedMemory = class {
   core;
@@ -3993,7 +4114,7 @@ var TypedMemory = class {
     this.resource = new ResourceMemoryImpl(backend);
     this.vault = new KnowledgeVaultImpl(backend);
     this.belief = new HindsightBeliefMemory();
-    logger6.info("TypedMemory initialized");
+    logger7.info("TypedMemory initialized");
   }
   async queryByType(type, query, limit = 20) {
     const result = await this.backend.search(`${type} ${query}`, limit);
@@ -4056,7 +4177,7 @@ var TypedMemory = class {
   async pruneExpired() {
     const result = await this.backend.prune(new Date(getTimeProvider().now()));
     if (!result.ok) return result;
-    logger6.info("Pruned expired entries", { count: result.value });
+    logger7.info("Pruned expired entries", { count: result.value });
     return ok({
       prunedCount: result.value,
       prunedByType: {
@@ -4099,11 +4220,11 @@ var MemoryPromoter = class {
   agentic;
   config;
   log;
-  constructor(beliefs, agentic, config = {}, logger7) {
+  constructor(beliefs, agentic, config = {}, logger8) {
     this.beliefs = beliefs;
     this.agentic = agentic;
     this.config = { ...DEFAULT_PROMOTION_CONFIG, ...config };
-    this.log = logger7 ?? createLogger({ component: "MemoryPromoter" });
+    this.log = logger8 ?? createLogger({ component: "MemoryPromoter" });
   }
   /**
    * Promote high-confidence session learnings to structured beliefs.
@@ -4256,8 +4377,8 @@ var DEFAULT_DECAY_CONFIG2 = {
 var CrossReferenceTracker = class {
   references = /* @__PURE__ */ new Map();
   log;
-  constructor(logger7) {
-    this.log = logger7 ?? createLogger({ component: "CrossReferenceTracker" });
+  constructor(logger8) {
+    this.log = logger8 ?? createLogger({ component: "CrossReferenceTracker" });
   }
   /**
    * Register a cross-reference between two memories.
@@ -4342,9 +4463,9 @@ var MemoryDecayManager = class {
   agentic = null;
   adaptive = null;
   mobimem = null;
-  constructor(config = {}, logger7) {
+  constructor(config = {}, logger8) {
     this.config = { ...DEFAULT_DECAY_CONFIG2, ...config };
-    this.log = logger7 ?? createLogger({ component: "MemoryDecayManager" });
+    this.log = logger8 ?? createLogger({ component: "MemoryDecayManager" });
     this.tracker = new CrossReferenceTracker(this.log);
   }
   /**
@@ -4744,8 +4865,8 @@ function attachToRegistry(domain, backend) {
   } catch {
   }
 }
-function getToolMemory(logger7) {
-  sharedInstance ??= new ToolMemoryManager(logger7, pendingOptions);
+function getToolMemory(logger8) {
+  sharedInstance ??= new ToolMemoryManager(logger8, pendingOptions);
   return sharedInstance;
 }
 function configureToolMemory(options) {
@@ -4785,8 +4906,8 @@ var ToolMemoryManager = class {
   decayConfig;
   decaySource;
   initPromise = null;
-  constructor(logger7, options = {}) {
-    this.log = logger7 ?? createLogger({ component: "ToolMemory" });
+  constructor(logger8, options = {}) {
+    this.log = logger8 ?? createLogger({ component: "ToolMemory" });
     this.decayConfig = definedDecayOverrides(options.decay ?? {});
     this.decaySource = options.decaySource ?? DECAY_SOURCE_NEVER_CONFIGURED;
     this.memory = new SessionMemory({
@@ -5684,4 +5805,4 @@ export {
   reinitializeMemoryBackends,
   ToolMemoryManager
 };
-//# sourceMappingURL=chunk-7FA6RW5Z.js.map
+//# sourceMappingURL=chunk-KOC6XT7R.js.map