openclaw-memory-alibaba-local 0.1.9-beta.7 → 1.0.0

package/capture-state.ts

@@ -166,7 +166,6 @@ function getMessageRoleRaw(msg: unknown): string {
 export function resolveRoleCountsForSession(
   entry: CursorFileEntry | undefined,
   messages: unknown[],
-  log: { info: (m: string) => void },
 ): { roleCounts: Record<string, number>; lastMessagesLength: number } {
   if (isV2Entry(entry)) {
     return {
@@ -176,7 +175,7 @@ export function resolveRoleCountsForSession(
   }
   if (isLegacyEntry(entry)) {
     const end = Math.min(Math.max(0, entry.lastEndExclusive), messages.length);
-    log.info("openclaw-memory-alibaba-local: migrated legacy full-context cursor to per-role counts");
+    console.log("[openclaw-memory-alibaba-local] migrated legacy full-context cursor to per-role counts");
     return {
       roleCounts: countRolesInMessagesPrefix(messages, end),
       lastMessagesLength: end,

package/categories.ts

@@ -8,6 +8,9 @@ export const USER_MEMORY_FACT = "user_memory_fact" as const;
 export const USER_MEMORY_PREFERENCE = "user_memory_preference" as const;
 export const USER_MEMORY_DECISION = "user_memory_decision" as const;
 
+/** World fact: event/entity memories from third-party conversations (LRU-managed). */
+export const WORLD_FACT = "world_fact" as const;
+
 /** All user memory category values (for recall: treat as one logical "user_memory" set) */
 export const USER_MEMORY_CATEGORIES = [
   USER_MEMORY_FACT,
@@ -15,11 +18,23 @@ export const USER_MEMORY_CATEGORIES = [
   USER_MEMORY_DECISION,
 ] as const;
 
+/** Categories to search during recall (user memories + world facts). */
+export const RECALL_USER_CATEGORIES = [
+  USER_MEMORY_FACT,
+  USER_MEMORY_PREFERENCE,
+  USER_MEMORY_DECISION,
+  WORLD_FACT,
+] as const;
+
 export type UserMemoryCategory =
   | typeof USER_MEMORY_FACT
   | typeof USER_MEMORY_PREFERENCE
   | typeof USER_MEMORY_DECISION;
 
+export function isWorldFact(cat: string): boolean {
+  return cat === WORLD_FACT;
+}
+
 /** Full context (conversation audit). Legacy single category. */
 export const FULL_CONTEXT_MEMORY = "full_context_memory" as const;
 
@@ -62,12 +77,14 @@ export type SelfImprovingCategory = (typeof SELF_IMPROVING_CATEGORIES)[number];
 /** All allowed category values */
 export type MemoryCategory =
   | UserMemoryCategory
+  | typeof WORLD_FACT
   | typeof FULL_CONTEXT_MEMORY
   | FullContextSourceCategory
   | SelfImprovingCategory;
 
 export const ALL_CATEGORIES: readonly MemoryCategory[] = [
   ...USER_MEMORY_CATEGORIES,
+  WORLD_FACT,
   FULL_CONTEXT_MEMORY,
   ...FULL_CONTEXT_SOURCE_CATEGORIES,
   ...SELF_IMPROVING_CATEGORIES,
@@ -103,6 +120,7 @@ export const MEMORY_CATEGORY_LABEL_ZH: Readonly<Record<MemoryCategory, string>>
   [USER_MEMORY_FACT]: "用户事实",
   [USER_MEMORY_PREFERENCE]: "用户偏好",
   [USER_MEMORY_DECISION]: "用户决策",
+  [WORLD_FACT]: "世界事实",
   [FULL_CONTEXT_MEMORY]: "全文记忆",
   [FULL_CONTEXT_USER]: "全文 · 用户消息",
   [FULL_CONTEXT_ASSISTANT]: "全文 · AI助手消息",

package/config.ts

@@ -6,9 +6,11 @@ import {
   ALL_CATEGORIES,
   FULL_CONTEXT_SOURCE_CATEGORIES,
   MEMORY_CATEGORY_LABEL_ZH,
+  RECALL_USER_CATEGORIES,
   SELF_IMPROVING_CATEGORIES,
   USER_MEMORY_CATEGORIES,
   USER_MEMORY_FACT,
+  WORLD_FACT,
 } from "./categories.js";
 
 /** OpenAI-compatible HTTP embeddings; all fields required — invalid/empty values fail on first embed, not at startup. */
@@ -52,7 +54,7 @@ export type AdminPanelMemoryTypeOptionsResolved = {
 
 const ADMIN_PANEL_TAB_KEYS = ["user", "self", "full"] as const;
 
-const USER_MEMORY_CAT_SET = new Set<string>(USER_MEMORY_CATEGORIES);
+const USER_MEMORY_CAT_SET = new Set<string>([...USER_MEMORY_CATEGORIES, WORLD_FACT]);
 const SELF_MEMORY_CAT_SET = new Set<string>(SELF_IMPROVING_CATEGORIES);
 const FULL_SOURCE_CAT_SET = new Set<string>(FULL_CONTEXT_SOURCE_CATEGORIES);
 
@@ -569,7 +571,7 @@ export const memoryConfigSchema = {
       enableFullContextMemory,
       enableSelfImprovingMemory,
       memoryExtractionMethod,
-      autoRecall: cfg.autoRecall === true,
+      autoRecall: cfg.autoRecall !== false,
       autoCapture: cfg.autoCapture !== false,
       captureMaxChars: captureMaxChars ?? DEFAULT_CAPTURE_MAX_CHARS,
       enableMemoryDecay,

package/db.ts

@@ -7,6 +7,7 @@ import {
   SELF_IMPROVING_CATEGORIES,
   USER_MEMORY_FACT,
   USER_MEMORY_CATEGORIES,
+  WORLD_FACT,
 } from "./categories.js";
 
 export type MemoryEntry = {
@@ -235,7 +236,7 @@ export type MemoryDashboardAggregate = {
   uniqueSessions: number;
 };
 
-const USER_CAT_SET = new Set<string>(USER_MEMORY_CATEGORIES);
+const USER_CAT_SET = new Set<string>([...USER_MEMORY_CATEGORIES, WORLD_FACT]);
 const SELF_CAT_SET = new Set<string>(SELF_IMPROVING_CATEGORIES);
 const FULL_CAT_SET = new Set<string>([FULL_CONTEXT_MEMORY, ...FULL_CONTEXT_SOURCE_CATEGORIES]);
 
@@ -733,6 +734,7 @@ export class MemoryDB {
 
     for (const raw of rows as Array<Record<string, unknown>>) {
       const cat = String(raw.category ?? "");
+      const displayCat = cat === WORLD_FACT ? USER_MEMORY_FACT : cat;
       const createdAt = Number(raw.createdAt ?? 0);
       const importance = Number(raw.importance ?? 0);
       const ag = String(raw.agentId ?? "").trim();
@@ -741,7 +743,7 @@ export class MemoryDB {
       const k = memoryCategoryKind(cat);
       byKind[k]++;
 
-      byCategory[cat] = (byCategory[cat] ?? 0) + 1;
+      byCategory[displayCat] = (byCategory[displayCat] ?? 0) + 1;
 
       if (ag) {
         agentCounts.set(ag, (agentCounts.get(ag) ?? 0) + 1);
@@ -1318,4 +1320,139 @@ export class MemoryDB {
     this.db = null;
     this.initPromise = null;
   }
+
+  /**
+   * Return top N user memory entries sorted by importance DESC.
+   * Used by session_start hook to inject key personal facts into a new session.
+   */
+  async listTopByImportance(
+    agentId: string,
+    categories: MemoryCategory[],
+    limit: number,
+  ): Promise<MemoryEntry[]> {
+    if (categories.length === 0 || limit <= 0) return [];
+    await this.ensureInitialized();
+    await this.refreshToLatest();
+    const a = sqlEscapeLiteral(agentId);
+    const list = categories.map((c) => `'${sqlEscapeLiteral(String(c))}'`).join(", ");
+    const where = `agentId = '${a}' AND isDeleted = 0 AND category IN (${list})`;
+    const rows = await this.table!
+      .query()
+      .where(where)
+      .select(["id", "agentId", "sessionId", "text", "importance", "category", "createdAt", "isDeleted", "batchId", "seqInBatch", "chunkIndex"])
+      .toArray();
+    const entries = (rows as Array<Record<string, unknown>>).map((r) => rowToEntry(r, agentId));
+    entries.sort((a, b) => b.importance - a.importance);
+    return entries.slice(0, limit);
+  }
+
+  /**
+   * GC full_context_* rows for a given agent:
+   * 1. Delete rows older than maxAgeMs.
+   * 2. If remaining count > maxRows, delete oldest until count <= maxRows.
+   */
+  async gcFullContext(
+    agentId: string,
+    maxRows: number,
+    maxAgeMs: number,
+  ): Promise<void> {
+    await this.ensureInitialized();
+    const a = sqlEscapeLiteral(agentId);
+    const cats = FULL_CONTEXT_SOURCE_CATEGORIES.map((c) => `'${sqlEscapeLiteral(String(c))}'`).join(", ");
+    const base = `agentId = '${a}' AND category IN (${cats})`;
+
+    // 1. Delete rows older than maxAgeMs
+    const cutoffMs = Date.now() - maxAgeMs;
+    const agePred = `${base} AND createdAt < ${Math.floor(cutoffMs)}`;
+    await this.table!.delete(agePred);
+
+    // 2. Count remaining; if over maxRows, trim oldest
+    const remaining = await this.table!.countRows(base);
+    if (remaining <= maxRows) {
+      console.log(`[openclaw-memory-alibaba-local] gcFullContext agent=${agentId} remaining=${remaining} (within limit)`);
+      return;
+    }
+    const excess = remaining - maxRows;
+    // Find the createdAt of the oldest rows to delete
+    const oldest: Array<Record<string, unknown>> = await this.table!.query()
+      .where(base)
+      .select(["createdAt"])
+      .toArray();
+    oldest.sort((a, b) => Number(a.createdAt) - Number(b.createdAt));
+    if (oldest.length > maxRows) {
+      const cutoff = Number(oldest[excess - 1]!.createdAt);
+      await this.table!.delete(`${base} AND createdAt <= ${Math.floor(cutoff)}`);
+    }
+    console.log(`[openclaw-memory-alibaba-local] gcFullContext agent=${agentId} deleted ${excess} excess rows (was ${remaining}, cap ${maxRows})`);
+  }
+
+  /**
+   * Touch world_fact entries: update createdAt to current UTC time (LRU refresh).
+   * Fire-and-forget: errors are logged but not thrown.
+   */
+  async touchWorldFactCreatedAt(agentId: string, ids: string[]): Promise<void> {
+    if (ids.length === 0) return;
+    await this.ensureInitialized();
+    const now = Date.now();
+    const a = sqlEscapeLiteral(agentId);
+    const wf = sqlEscapeLiteral(WORLD_FACT);
+    for (const id of ids) {
+      try {
+        const eid = sqlEscapeLiteral(id);
+        await (this.table! as any).update(
+          { createdAt: now },
+          { where: `id = '${eid}' AND agentId = '${a}' AND category = '${wf}'` },
+        );
+      } catch (err) {
+        console.warn(`[openclaw-memory-alibaba-local] touchWorldFactCreatedAt failed id=${id}: ${err}`);
+      }
+    }
+  }
+
+  /**
+   * GC world_fact rows for a given agent (LRU eviction):
+   * Phase 1: If count > softMaxRows, delete rows where createdAt > maxAgeMs old AND importance < 0.7.
+   * Phase 2: If count still > hardMaxRows, delete oldest rows regardless of importance.
+   */
+  async gcWorldFact(
+    agentId: string,
+    softMaxRows: number,
+    maxAgeMs: number,
+    hardMaxRows: number,
+  ): Promise<void> {
+    await this.ensureInitialized();
+    const a = sqlEscapeLiteral(agentId);
+    const wf = sqlEscapeLiteral(WORLD_FACT);
+    const base = `agentId = '${a}' AND category = '${wf}'`;
+
+    let count = await this.table!.countRows(base);
+
+    // Phase 1: soft GC — delete old + low-importance entries when count > softMaxRows
+    if (count > softMaxRows) {
+      const cutoffMs = Date.now() - maxAgeMs;
+      const softPred = `${base} AND createdAt < ${Math.floor(cutoffMs)} AND importance < 0.7`;
+      await this.table!.delete(softPred);
+      const afterSoft = await this.table!.countRows(base);
+      const softDeleted = count - afterSoft;
+      if (softDeleted > 0) {
+        console.log(`[openclaw-memory-alibaba-local] gcWorldFact agent=${agentId} phase1: deleted ${softDeleted} old+low-importance rows (was ${count}, now ${afterSoft})`);
+      }
+      count = afterSoft;
+    }
+
+    // Phase 2: hard cap — delete oldest regardless of importance
+    if (count > hardMaxRows) {
+      const excess = count - hardMaxRows;
+      const oldest: Array<Record<string, unknown>> = await this.table!.query()
+        .where(base)
+        .select(["createdAt"])
+        .toArray();
+      oldest.sort((a, b) => Number(a.createdAt) - Number(b.createdAt));
+      if (oldest.length > hardMaxRows) {
+        const cutoff = Number(oldest[excess - 1]!.createdAt);
+        await this.table!.delete(`${base} AND createdAt <= ${Math.floor(cutoff)}`);
+      }
+      console.log(`[openclaw-memory-alibaba-local] gcWorldFact agent=${agentId} phase2: deleted ${excess} excess rows (was ${count}, cap ${hardMaxRows})`);
+    }
+  }
 }