@yhc3577/memory-new 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,54 +1,1660 @@
 // index.ts
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+// src/store/storage.ts
+import { mkdirSync, writeFileSync, readFileSync, existsSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
+var STORAGE_PATHS = {
+  l0: "memory/l0/",
+  l1: "memory/l1/",
+  l2: "memory/scenes/",
+  l3: "persona.md",
+  index: {
+    l2: "memory/scenes/index.json",
+    l3: "persona.md.meta"
+  }
+};
+var StorageAdapter = class {
+  baseDir;
+  constructor(baseDir = "~/.openclaw/memory-new") {
+    this.baseDir = baseDir.replace("~", process.env.HOME || "/root");
+    mkdirSync(this.baseDir, { recursive: true });
+  }
+  resolve(path) {
+    return join(this.baseDir, path);
+  }
+  // ========== File Operations ==========
+  async readFile(key) {
+    const filePath = this.resolve(key);
+    if (!existsSync(filePath)) return null;
+    return readFileSync(filePath, "utf-8");
+  }
+  async writeFile(key, content) {
+    const filePath = this.resolve(key);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content, "utf-8");
+  }
+  async appendFile(key, content) {
+    const filePath = this.resolve(key);
+    mkdirSync(dirname(filePath), { recursive: true });
+    appendFileSync(filePath, content, "utf-8");
+  }
+  async exists(key) {
+    return existsSync(this.resolve(key));
+  }
+  // ========== L0 Operations (JSONL per session) ==========
+  /**
+   * L0: Append message to session's JSONL file (TDB pattern: append-only)
+   */
+  async appendL0(record) {
+    const sessionFile = `${STORAGE_PATHS.l0}${record.sessionKey}.jsonl`;
+    const line = JSON.stringify(record) + "\n";
+    await this.appendFile(sessionFile, line);
+  }
+  /**
+   * L0: Batch read messages from session
+   */
+  async readL0(sessionKey, limit = 100) {
+    const sessionFile = `${STORAGE_PATHS.l0}${sessionKey}.jsonl`;
+    const content = await this.readFile(sessionFile);
+    if (!content) return [];
+    const lines = content.split("\n").filter((l) => l.trim());
+    const messages = lines.slice(-limit).map((line) => JSON.parse(line));
+    return messages;
+  }
+  // ========== L1 Operations (JSONL) ==========
+  /**
+   * L1: Append atomic memory to session's JSONL file
+   */
+  async appendL1(record) {
+    const sessionFile = `${STORAGE_PATHS.l1}${record.sessionKey}.jsonl`;
+    const line = JSON.stringify(record) + "\n";
+    await this.appendFile(sessionFile, line);
+  }
+  /**
+   * L1: Search memories by content (simple full-text scan)
+   */
+  async searchL1(query, limit = 10) {
+    const content = await this.readFile(`${STORAGE_PATHS.l1}*.jsonl`);
+    if (!content) return [];
+    const lines = content.split("\n").filter((l) => l.trim());
+    const allRecords = lines.map((line) => JSON.parse(line));
+    const queryLower = query.toLowerCase();
+    return allRecords.filter((r) => r.content.toLowerCase().includes(queryLower)).slice(0, limit);
+  }
+  // ========== L2 Operations (Markdown files) ==========
+  /**
+   * L2: Write scene block as Markdown file
+   */
+  async writeScene(scene2) {
+    const sceneFile = `${STORAGE_PATHS.l2}${scene2.id}.md`;
+    const frontmatter = `---
+id: ${scene2.id}
+title: ${scene2.title}
+summary: ${scene2.summary}
+tags: ${JSON.stringify(scene2.tags)}
+created_at: ${scene2.createdAt}
+updated_at: ${scene2.updatedAt}
+---
+
+`;
+    await this.writeFile(sceneFile, frontmatter + scene2.content);
+    await this.updateSceneIndex(scene2);
+  }
+  /**
+   * L2: Read scene block
+   */
+  async readScene(sceneId) {
+    const content = await this.readFile(`${STORAGE_PATHS.l2}${sceneId}.md`);
+    if (!content) return null;
+    const lines = content.split("\n");
+    const frontmatterEnd = lines.findIndex((l) => l === "---", 1);
+    if (frontmatterEnd <= 1) return null;
+    const frontmatter = {};
+    for (let i = 1; i < frontmatterEnd; i++) {
+      const [key, ...valueParts] = lines[i].split(":");
+      if (key && valueParts.length > 0) {
+        frontmatter[key.trim()] = valueParts.join(":").trim();
+      }
+    }
+    return {
+      id: scene.id,
+      title: frontmatter.title || "",
+      content: lines.slice(frontmatterEnd + 1).join("\n"),
+      summary: frontmatter.summary || "",
+      tags: JSON.parse(frontmatter.tags || "[]"),
+      metadata: { layer: "L2", heat: 0, sourceRecords: [] },
+      createdAt: frontmatter.created_at || "",
+      updatedAt: frontmatter.updated_at || ""
+    };
+  }
+  /**
+   * L2: Maintain scene index for navigation
+   */
+  async updateSceneIndex(scene2) {
+    const indexFile = STORAGE_PATHS.index.l2;
+    let index = {};
+    const existing = await this.readFile(indexFile);
+    if (existing) {
+      try {
+        index = JSON.parse(existing);
+      } catch {
+      }
+    }
+    index[scene2.id] = {
+      id: scene2.id,
+      title: scene2.title,
+      summary: scene2.summary,
+      tags: scene2.tags
+    };
+    await this.writeFile(indexFile, JSON.stringify(index, null, 2));
+  }
+  /**
+   * L2: Read scene index for navigation
+   */
+  async readSceneIndex() {
+    const indexFile = STORAGE_PATHS.index.l2;
+    const content = await this.readFile(indexFile);
+    if (!content) return [];
+    try {
+      const index = JSON.parse(content);
+      return Object.values(index);
+    } catch {
+      return [];
+    }
+  }
+  // ========== L3 Operations (persona.md) ==========
+  /**
+   * L3: Write persona file
+   */
+  async writePersona(persona) {
+    const frontmatter = `---
+id: ${persona.id}
+created_at: ${persona.createdAt}
+updated_at: ${persona.updatedAt}
+---
+
+`;
+    await this.writeFile(STORAGE_PATHS.l3, frontmatter + persona.content);
+  }
+  /**
+   * L3: Read persona file
+   */
+  async readPersona() {
+    const content = await this.readFile(STORAGE_PATHS.l3);
+    if (!content) return null;
+    const lines = content.split("\n");
+    const frontmatterEnd = lines.findIndex((l) => l === "---", 1);
+    if (frontmatterEnd <= 1) return null;
+    const frontmatter = {};
+    for (let i = 1; i < frontmatterEnd; i++) {
+      const [key, ...valueParts] = lines[i].split(":");
+      if (key && valueParts.length > 0) {
+        frontmatter[key.trim()] = valueParts.join(":").trim();
+      }
+    }
+    return {
+      id: frontmatter.id || "",
+      content: lines.slice(frontmatterEnd + 1).join("\n"),
+      summary: "",
+      metadata: { layer: "L3", sourceScenes: [] },
+      createdAt: frontmatter.created_at || "",
+      updatedAt: frontmatter.updated_at || ""
+    };
+  }
+};
+var RECALL_LINE_SEPARATOR = "\n";
+var MEMORY_TOOLS_GUIDE = `<memory-tools-guide>
+## \u8BB0\u5FC6\u5DE5\u5177\u8C03\u7528\u6307\u5357
+
+\u5F53\u4E0A\u65B9\u6CE8\u5165\u7684\u8BB0\u5FC6\u7247\u6BB5\u4E0D\u8DB3\u4EE5\u56DE\u7B54\u7528\u6237\u95EE\u9898\u65F6\uFF0C\u53EF\u4E3B\u52A8\u8C03\u7528\u4EE5\u4E0B\u5DE5\u5177\u83B7\u53D6\u66F4\u591A\u4FE1\u606F\uFF1A
+
+- **memory_search**\uFF1A\u641C\u7D22\u7ED3\u6784\u5316\u8BB0\u5FC6\uFF08L1\uFF09\uFF0C\u9002\u7528\u4E8E\u56DE\u5FC6\u7528\u6237\u504F\u597D\u3001\u5386\u53F2\u4E8B\u4EF6\u8282\u70B9\u3001\u89C4\u5219\u7B49\u5173\u952E\u4FE1\u606F\u3002
+- **memory_get**\uFF1A\u83B7\u53D6\u7279\u5B9A\u8BB0\u5FC6\u8BE6\u60C5\u3002
+
+### \u8C03\u7528\u6B21\u6570\u9650\u5236
+\u6BCF\u8F6E\u5BF9\u8BDD\u4E2D\uFF0C\u8BB0\u5FC6\u641C\u7D22\u5DE5\u5177**\u5408\u8BA1\u6700\u591A\u8C03\u7528 3 \u6B21**\u3002
+</memory-tools-guide>`;
+function generateSceneNavigation(scenes) {
+  if (scenes.length === 0) return "";
+  const lines = scenes.map(
+    (s) => `- [${s.title}](memory://scene/${s.id}): ${s.summary}`
+  );
+  return `## \u60C5\u5883\u5BFC\u822A
+${lines.join(RECALL_LINE_SEPARATOR)}`;
+}
+var RecallEngine = class {
+  storage;
+  options;
+  constructor(storage, options = {}) {
+    this.storage = storage;
+    this.options = {
+      hybridSearch: options.hybridSearch ?? true,
+      semanticWeight: options.semanticWeight ?? 0.5,
+      bm25Weight: options.bm25Weight ?? 0.25,
+      entityBoostWeight: options.entityBoostWeight ?? 0.25
+    };
+  }
+  /**
+   * Perform recall: search L1 + read L2 + read L3
+   * (Reference: TDB's performAutoRecallCore)
+   *
+   * Uses hybrid search when vector store is available via hybridSearch option.
+   */
+  async recall(params) {
+    const { query, sessionKey, topK = 10, vectorStore } = params;
+    let memories = [];
+    let recallStrategy = "text";
+    if (vectorStore && this.options.hybridSearch) {
+      const searchResults = await vectorStore.hybridSearch({
+        query,
+        topK,
+        semanticWeight: this.options.semanticWeight,
+        bm25Weight: this.options.bm25Weight,
+        entityBoostWeight: this.options.entityBoostWeight
+      });
+      const matchedRecords = [];
+      for (const result of searchResults) {
+        const records = await this.storage.searchL1("", 100);
+        const record = records.find((r) => r.id === result.id);
+        if (record) {
+          matchedRecords.push(record);
+        }
+      }
+      memories = matchedRecords;
+      recallStrategy = "hybrid";
+    } else {
+      memories = await this.storage.searchL1(query, topK);
+      recallStrategy = "text";
+    }
+    const sceneIndex = await this.storage.readSceneIndex();
+    const persona = await this.storage.readPersona();
+    let prependContext;
+    if (memories.length > 0) {
+      const memoryLines = memories.map(
+        (m) => `- [${m.type}] ${m.content}`
+      );
+      prependContext = `<relevant-memories>
+\u4EE5\u4E0B\u662F\u4E0E\u5F53\u524D\u5BF9\u8BDD\u76F8\u5173\u7684\u8BB0\u5FC6\uFF1A
+
+${memoryLines.join(RECALL_LINE_SEPARATOR)}
+</relevant-memories>`;
+    }
+    const stableParts = [];
+    if (persona) {
+      stableParts.push(`<user-persona>
+${persona.content}
+</user-persona>`);
+    }
+    if (sceneIndex.length > 0) {
+      stableParts.push(`<scene-navigation>
+${generateSceneNavigation(sceneIndex)}
+</scene-navigation>`);
+    }
+    if (stableParts.length > 0 || prependContext) {
+      stableParts.push(MEMORY_TOOLS_GUIDE);
+    }
+    const appendSystemContext = stableParts.length > 0 ? stableParts.join("\n\n") : void 0;
+    return {
+      prependContext,
+      appendSystemContext,
+      recalledL1Memories: memories.map((m) => ({
+        content: m.content,
+        score: 0.5,
+        // TODO: calculate real score
+        type: m.type
+      })),
+      recalledL3Persona: persona?.content ?? null,
+      recallStrategy
+    };
+  }
+};
+var MemoryStore = class {
+  storage;
+  recall;
+  _vectorStore;
+  constructor(baseDir = "~/.openclaw/memory-new") {
+    this.storage = new StorageAdapter(baseDir);
+    this.recall = new RecallEngine(this.storage);
+  }
+  // ========== Vector Store (for semantic search) ==========
+  get vectorStore() {
+    return this._vectorStore;
+  }
+  setVectorStore(store) {
+    this._vectorStore = store;
+  }
+  // ========== L0 Operations ==========
+  async ingestMessage(message) {
+    const record = {
+      ...message,
+      id: `l0_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.storage.appendL0(record);
+    return record;
+  }
+  async getMessages(sessionKey, limit = 100) {
+    return this.storage.readL0(sessionKey, limit);
+  }
+  // ========== L1 Operations ==========
+  async storeL1(record) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fullRecord = {
+      ...record,
+      id: `l1_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      createdAt: now,
+      updatedAt: now,
+      version: 1
+    };
+    await this.storage.appendL1(fullRecord);
+    return fullRecord;
+  }
+  async searchL1(query, limit = 10) {
+    return this.storage.searchL1(query, limit);
+  }
+  // ========== L2 Operations ==========
+  async storeL2(scene2) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fullScene = {
+      ...scene2,
+      id: `scene_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.storage.writeScene(fullScene);
+    return fullScene;
+  }
+  async getScene(sceneId) {
+    return this.storage.readScene(sceneId);
+  }
+  async getSceneIndex() {
+    return this.storage.readSceneIndex();
+  }
+  // ========== L3 Operations ==========
+  async storeL3(persona) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fullPersona = {
+      ...persona,
+      id: `persona_${Date.now()}`,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.storage.writePersona(fullPersona);
+    return fullPersona;
+  }
+  async getPersona() {
+    return this.storage.readPersona();
+  }
+  // ========== Recall ==========
+  async recallMemories(query, sessionKey, userId, agentId, topK) {
+    return this.recall.recall({ query, sessionKey, userId, agentId, topK });
+  }
+};
+
+// src/vector/vector-store.ts
+var VectorStore = class {
+  records = /* @__PURE__ */ new Map();
+  embeddingProvider = null;
+  dimension = 384;
+  constructor(dimension = 384) {
+    this.dimension = dimension;
+  }
+  setEmbeddingProvider(provider) {
+    this.embeddingProvider = provider;
+  }
+  // ========== Record Operations ==========
+  async add(record) {
+    const fullRecord = {
+      ...record,
+      createdAt: Date.now()
+    };
+    this.records.set(record.id, fullRecord);
+    return fullRecord;
+  }
+  async get(id) {
+    return this.records.get(id) ?? null;
+  }
+  async delete(id) {
+    return this.records.delete(id);
+  }
+  async update(id, updates) {
+    const existing = this.records.get(id);
+    if (!existing) return null;
+    const updated = { ...existing, ...updates };
+    this.records.set(id, updated);
+    return updated;
+  }
+  // ========== Embedding Operations ==========
+  async embedContent(content) {
+    if (!this.embeddingProvider) {
+      return this.fallbackEmbed(content);
+    }
+    try {
+      const embedding = await this.embeddingProvider.embed(content, { inputType: "query" });
+      return embedding;
+    } catch (error) {
+      console.error("Embedding failed, using fallback:", error);
+      return this.fallbackEmbed(content);
+    }
+  }
+  async embedBatch(contents) {
+    if (!this.embeddingProvider) {
+      return contents.map((c) => this.fallbackEmbed(c));
+    }
+    try {
+      return await this.embeddingProvider.embedBatch(contents, { inputType: "document" });
+    } catch (error) {
+      console.error("Batch embedding failed, using fallback:", error);
+      return contents.map((c) => this.fallbackEmbed(c));
+    }
+  }
+  // Fallback pseudo-embedding using hash (for testing without API)
+  fallbackEmbed(content) {
+    return this.generatePseudoEmbedding(content);
+  }
+  /**
+   * Generate pseudo-embedding from text content.
+   * Used as fallback when no embedding provider is available.
+   */
+  generatePseudoEmbedding(content) {
+    const embedding = new Array(this.dimension).fill(0);
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      hash = (hash << 5) - hash + content.charCodeAt(i);
+      hash = hash & hash;
+    }
+    const seed = Math.abs(hash);
+    for (let i = 0; i < this.dimension; i++) {
+      const charCode = content.charCodeAt(i % content.length) || 1;
+      embedding[i] = Math.sin(seed * (i + 1) * charCode) * 0.5 + 0.5;
+    }
+    const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0));
+    if (magnitude > 0) {
+      for (let i = 0; i < embedding.length; i++) {
+        embedding[i] /= magnitude;
+      }
+    }
+    return embedding;
+  }
+  // ========== Vector Search ==========
+  async searchByVector(queryEmbedding, topK, minScore = 0) {
+    const results = [];
+    for (const record of this.records.values()) {
+      if (record.embedding.length !== queryEmbedding.length) continue;
+      const score = this.cosineSimilarity(queryEmbedding, record.embedding);
+      if (score >= minScore) {
+        results.push({
+          id: record.id,
+          content: record.content,
+          score,
+          metadata: record.metadata
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  // ========== Hybrid Search ==========
+  async hybridSearch(options, getTextScore = bm25Score) {
+    const { query, topK, semanticWeight, bm25Weight, entityBoostWeight, minScore = 0.1 } = options;
+    let queryEmbedding = options.queryEmbedding;
+    if (!queryEmbedding) {
+      queryEmbedding = await this.embedContent(query);
+    }
+    const semanticResults = await this.searchByVector(queryEmbedding, topK * 2, 0);
+    const bm25Results = this.bm25Search(query, topK * 2);
+    const entities = this.extractEntities(query);
+    const entityBoostResults = this.entityBoostSearch(entities, topK * 2);
+    const scoreMap = /* @__PURE__ */ new Map();
+    for (const result of semanticResults) {
+      const semanticScore = result.score * semanticWeight;
+      scoreMap.set(result.id, {
+        id: result.id,
+        content: result.content,
+        score: semanticScore,
+        metadata: result.metadata
+      });
+    }
+    for (const result of bm25Results) {
+      const existing = scoreMap.get(result.id);
+      const bm25Contribution = result.score * bm25Weight;
+      if (existing) {
+        existing.score += bm25Contribution;
+      } else {
+        scoreMap.set(result.id, {
+          id: result.id,
+          content: result.content,
+          score: bm25Contribution,
+          metadata: result.metadata
+        });
+      }
+    }
+    for (const result of entityBoostResults) {
+      const existing = scoreMap.get(result.id);
+      const boostContribution = result.score * entityBoostWeight;
+      if (existing) {
+        existing.score += boostContribution;
+      } else {
+        scoreMap.set(result.id, {
+          id: result.id,
+          content: result.content,
+          score: boostContribution,
+          metadata: result.metadata
+        });
+      }
+    }
+    const finalResults = Array.from(scoreMap.values()).filter((r) => r.score >= minScore).sort((a, b) => b.score - a.score).slice(0, topK);
+    return finalResults;
+  }
+  // ========== BM25 (in-memory simplified) ==========
+  bm25Search(query, topK) {
+    const queryTerms = query.toLowerCase().split(/\s+/);
+    const results = [];
+    const avgDocLen = this.getAverageDocLength();
+    const k1 = 1.5;
+    const b = 0.75;
+    for (const record of this.records.values()) {
+      const terms = record.content.toLowerCase().split(/\s+/);
+      let score = 0;
+      for (const term of queryTerms) {
+        const tf = terms.filter((t) => t === term).length;
+        if (tf > 0) {
+          const idf = Math.log((this.records.size + 1) / 2);
+          const docLen = terms.length;
+          const numerator = tf * (k1 + 1);
+          const denominator = tf + k1 * (1 - b + b * (docLen / avgDocLen));
+          score += idf * (numerator / denominator);
+        }
+      }
+      if (score > 0) {
+        results.push({
+          id: record.id,
+          content: record.content,
+          score,
+          metadata: record.metadata
+        });
+      }
+    }
+    results.sort((a, b2) => b2.score - a.score);
+    return results.slice(0, topK);
+  }
+  getAverageDocLength() {
+    if (this.records.size === 0) return 1;
+    let total = 0;
+    for (const record of this.records.values()) {
+      total += record.content.split(/\s+/).length;
+    }
+    return total / this.records.size;
+  }
+  // ========== Entity Extraction & Boost ==========
+  extractEntities(query) {
+    const entities = [];
+    const capitalizedPattern = /[A-Z][a-z]+/g;
+    let match;
+    while ((match = capitalizedPattern.exec(query)) !== null) {
+      entities.push(match[0].toLowerCase());
+    }
+    const quotedPattern = /"([^"]+)"|'([^']+)'/g;
+    while ((match = quotedPattern.exec(query)) !== null) {
+      const entity = match[1] || match[2];
+      entities.push(entity.toLowerCase());
+    }
+    return [...new Set(entities)];
+  }
+  entityBoostSearch(entities, topK) {
+    if (entities.length === 0) return [];
+    const results = [];
+    for (const record of this.records.values()) {
+      const content = record.content.toLowerCase();
+      let matchCount = 0;
+      for (const entity of entities) {
+        if (content.includes(entity)) {
+          matchCount++;
+        }
+      }
+      if (matchCount > 0) {
+        const score = matchCount / entities.length;
+        results.push({
+          id: record.id,
+          content: record.content,
+          score,
+          metadata: record.metadata
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  // ========== Utilities ==========
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0) return 0;
+    return dotProduct / denominator;
+  }
+  async getAll() {
+    return Array.from(this.records.values());
+  }
+  async count() {
+    return this.records.size;
+  }
+  async clear() {
+    this.records.clear();
+  }
+};
+function bm25Score(content, query) {
+  const queryTerms = query.toLowerCase().split(/\s+/);
+  const terms = content.toLowerCase().split(/\s+/);
+  let score = 0;
+  for (const term of queryTerms) {
+    const tf = terms.filter((t) => t === term).length;
+    if (tf > 0) {
+      score += 1 + Math.log(1 + tf);
+    }
+  }
+  return score;
+}
+
+// src/pipeline/distillation.ts
+var DEFAULT_DISTILLATION_CONFIG = {
+  l1: {
+    messageThreshold: 5,
+    idleSeconds: 60,
+    batchSize: 10,
+    enableDedup: true,
+    maxMemoriesPerSession: 50
+  },
+  l2: {
+    minIntervalMs: 15 * 60 * 1e3,
+    maxIntervalMs: 60 * 60 * 1e3,
+    topicThreshold: 3,
+    delayAfterL1Seconds: 90
+  },
+  l3: {
+    conditions: ["explicit_request", "cold_start", "restore", "first_scene", "threshold"],
+    importanceThreshold: 0.6
+  }
+};
+var L1_EXTRACTION_SYSTEM_PROMPT = `\u4F60\u662F\u4E13\u4E1A\u7684"\u5DE5\u4F5C\u60C5\u5883\u5207\u5206\u4E0E\u56E2\u961F\u5171\u4EAB\u8BB0\u5FC6\u63D0\u53D6\u4E13\u5BB6"\u3002
+\u4F60\u7684\u4EFB\u52A1\u662F\u5206\u6790\u5DE5\u4F5C\u6D88\u606F\uFF0C\u5224\u65AD\u5DE5\u4F5C\u60C5\u5883\u5207\u6362\uFF0C\u5E76\u4ECE\u4E2D\u63D0\u53D6\u53EF\u5728\u56E2\u961F\u5185\u5171\u4EAB\u7684\u7ED3\u6784\u5316\u5DE5\u4F5C\u8BB0\u5FC6\u3002
+
+## \u8F93\u51FA\u8981\u6C42
+
+\u4E25\u683C\u6309\u4EE5\u4E0BJSON\u6570\u7EC4\u683C\u5F0F\u8F93\u51FA\uFF0C\u4E0D\u8981\u8F93\u51FA\u4EFB\u4F55\u989D\u5916\u7684 Markdown \u4EE3\u7801\u5757\u4FEE\u9970\u7B26\uFF08\u5982 \`\`\`json\uFF09\u6216\u89E3\u91CA\u6587\u672C\uFF1A
+
+[
+  {
+    "scene_name": "\u60C5\u5883\u540D\u79F0\uFF08\u7B80\u6D01\uFF0C1-10\u4E2A\u5B57\uFF09",
+    "memories": [
+      {
+        "content": "\u8BB0\u5FC6\u5185\u5BB9\uFF08\u5B8C\u6574\u53E5\u5B50\uFF0C20-200\u5B57\uFF09",
+        "type": "persona | episodic | instruction",
+        "priority": \u4F18\u5148\u7EA7(0-100, \u8D8A\u9AD8\u8D8A\u91CD\u8981),
+        "source_message_ids": ["\u76F8\u5173\u6D88\u606FID"],
+        "metadata": {}
+      }
+    ]
+  }
+]
+
+## Memory Type \u5B9A\u4E49
+
+- **persona**: \u5173\u4E8E\u7528\u6237\u504F\u597D\u3001\u4E60\u60EF\u3001\u5DE5\u4F5C\u65B9\u5F0F\u7684\u8BB0\u5FC6\uFF08\u5982"\u7528\u6237\u559C\u6B22\u5728\u4E0A\u5348\u5904\u7406\u590D\u6742\u4EFB\u52A1"\uFF09
+- **episodic**: \u5177\u4F53\u7684\u9879\u76EE\u4E8B\u4EF6\u3001\u51B3\u7B56\u3001\u8BA8\u8BBA\u8981\u70B9\uFF08\u5982"\u9879\u76EEX\u51B3\u5B9A\u4F7F\u7528\u5FAE\u670D\u52A1\u67B6\u6784"\uFF09
+- **instruction**: \u7528\u6237\u7684\u660E\u786E\u6307\u4EE4\u6216\u9700\u6C42\uFF08\u5982"\u7528\u6237\u8981\u6C42\u6BCF\u5468\u4E94\u540C\u6B65\u8FDB\u5EA6"\uFF09
+
+## \u573A\u666F\u5207\u6362\u5224\u65AD
+
+\u5F53\u51FA\u73B0\u4EE5\u4E0B\u60C5\u51B5\u65F6\uFF0C\u5E94\u8BE5\u5207\u6362\u5230\u65B0\u573A\u666F\uFF1A
+1. \u8BDD\u9898\u53D1\u751F\u5B9E\u8D28\u6027\u53D8\u5316
+2. \u53C2\u4E0E\u4EBA\u5458\u53D1\u751F\u660E\u663E\u53D8\u5316
+3. \u4EFB\u52A1\u76EE\u6807\u53D1\u751F\u5207\u6362
+4. \u65F6\u95F4\u95F4\u9694\u8D85\u8FC730\u5206\u949F`;
+function formatExtractionPrompt(newMessages, backgroundMessages, previousSceneName) {
+  const bgText = backgroundMessages.length > 0 ? backgroundMessages.map((m) => `[${m.id}] [${m.role}] [${new Date(m.timestamp).toISOString()}]: ${m.content}`).join("\n\n") : "\u65E0";
+  const newText = newMessages.map((m) => `[${m.id}] [${m.role}] [${new Date(m.timestamp).toISOString()}]: ${m.content}`).join("\n\n");
+  const userPrompt = `**\u8F93\u51FA\u8BED\u8A00**\uFF1A\u6839\u636E\u4E0B\u65B9"\u5F85\u63D0\u53D6\u7684\u65B0\u6D88\u606F"\u4E2D user \u53D1\u8A00\u7684\u4E3B\u5BFC\u8BED\u8A00\u4E66\u5199 \`scene_name\` \u548C memory \`content\`\u3002
+
+\u3010\u4E0A\u4E00\u4E2A\u60C5\u5883\u3011\uFF1A${previousSceneName || "\u65E0"}
+
+\u3010\u80CC\u666F\u5BF9\u8BDD\u3011\uFF08\u4EC5\u4F9B\u7406\u89E3\u4E0A\u4E0B\u6587\u63A8\u65AD\u5173\u7CFB/\u65F6\u95F4\uFF0C\u4E25\u7981\u4ECE\u4E2D\u63D0\u53D6\u8BB0\u5FC6\uFF09\uFF1A
+${bgText}
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+\u3010\u5F85\u63D0\u53D6\u7684\u65B0\u6D88\u606F\u3011\uFF08\u52A1\u5FC5\u7ED3\u5408 timestamp \u63A8\u7B97\u65F6\u95F4\uFF0C\u53EA\u4ECE\u8FD9\u91CC\u63D0\u53D6\u8BB0\u5FC6\uFF01\uFF09\uFF1A
+${newText}`;
+  return {
+    systemPrompt: L1_EXTRACTION_SYSTEM_PROMPT,
+    userPrompt
+  };
+}
+var DistillationPipeline = class {
+  config;
+  store;
+  vectorStore;
+  llmRunner;
+  subagentRunner;
+  lastL1At = null;
+  lastL2At = null;
+  lastL3At = null;
+  pendingL1Extraction = null;
+  // In-memory buffers (TDB uses VectorStore + JSONL)
+  messageBuffer = [];
+  constructor(config = DEFAULT_DISTILLATION_CONFIG, store, vectorStore, llmRunner) {
+    this.config = config;
+    this.store = store || new MemoryStore();
+    this.vectorStore = vectorStore || new VectorStore();
+    this.llmRunner = llmRunner;
+  }
+  /**
+   * Set LLM runner for simple prompt-completion style extraction
+   */
+  setLLMRunner(runner) {
+    this.llmRunner = runner;
+  }
+  /**
+   * Set subagent runner for L1 extraction via OpenClaw subagent runtime
+   */
+  setSubagentRunner(runner) {
+    this.subagentRunner = runner;
+  }
+  /**
+   * Set vector store for embedding-based search
+   */
+  setVectorStore(store) {
+    this.vectorStore = store;
+  }
+  // ============================================================================
+  // Ingestion (L0)
+  // ============================================================================
+  /**
+   * Ingest messages into L0 layer (TDB's captureAtomic pattern)
+   */
+  async ingest(messages) {
+    const records = [];
+    for (const msg of messages) {
+      if (!shouldExtractL1(msg.content)) continue;
+      const record = await this.store.ingestMessage(msg);
+      records.push(record);
+      this.messageBuffer.push(record);
+    }
+    if (this.messageBuffer.length >= this.config.l1.messageThreshold) {
+      await this.triggerL1Extraction();
+    } else {
+      this.scheduleL1Extraction();
+    }
+    return records;
+  }
+  scheduleL1Extraction() {
+    if (this.pendingL1Extraction) return;
+    this.pendingL1Extraction = setTimeout(async () => {
+      this.pendingL1Extraction = null;
+      if (this.messageBuffer.length > 0) {
+        await this.distill("L1");
+      }
+    }, this.config.l1.idleSeconds * 1e3);
+  }
+  async triggerL1Extraction() {
+    if (this.pendingL1Extraction) {
+      clearTimeout(this.pendingL1Extraction);
+      this.pendingL1Extraction = null;
+    }
+    await this.distill("L1");
+  }
+  // ============================================================================
+  // Distillation
+  // ============================================================================
+  async distill(stage) {
+    switch (stage) {
+      case "L1":
+        return this.runL1Distillation();
+      case "L2":
+        return this.runL2Distillation();
+      case "L3":
+        return this.runL3Distillation();
+      default:
+        return { stage, produced: 0, errors: ["Unknown stage"] };
+    }
+  }
+  /**
+   * L1 Distillation: Extract atomic memories from L0 messages
+   * (Reference: TDB's extractL1Memories)
+   */
+  async runL1Distillation() {
+    const errors = [];
+    let produced = 0;
+    try {
+      const messages = this.messageBuffer.slice(-this.config.l1.batchSize);
+      if (messages.length === 0) {
+        return { stage: "L1", produced: 0, errors: [] };
+      }
+      const lastScene = await this.getLastSceneName();
+      const maxNew = 5;
+      const newMessages = messages.slice(-maxNew);
+      const backgroundMessages = messages.slice(0, -maxNew);
+      const { systemPrompt, userPrompt } = formatExtractionPrompt(
+        newMessages,
+        backgroundMessages,
+        lastScene
+      );
+      let extractionOutput = "";
+      if (this.subagentRunner) {
+        const fullPrompt = `${systemPrompt}
+
+${userPrompt}`;
+        extractionOutput = await this.subagentRunner(fullPrompt);
+      } else if (this.llmRunner) {
+        extractionOutput = await this.llmRunner(systemPrompt, userPrompt);
+      } else {
+        extractionOutput = this.fallbackExtract(messages, lastScene);
+      }
+      const extractedMemories = parseExtractionOutput(extractionOutput);
+      for (const mem of extractedMemories) {
+        await this.store.storeL1({
+          content: mem.content,
+          type: mem.type,
+          priority: mem.priority,
+          sceneName: mem.scene_name,
+          sourceMessageIds: mem.source_message_ids,
+          metadata: mem.metadata,
+          timestamps: messages.map((m) => new Date(m.timestamp).toISOString()),
+          sessionKey: messages[0]?.sessionKey || "default",
+          sessionId: messages[0]?.sessionId || "",
+          teamId: messages[0]?.teamId,
+          userId: messages[0]?.userId || "",
+          agentId: messages[0]?.agentId || ""
+        });
+        produced++;
+      }
+      this.messageBuffer = this.messageBuffer.slice(0, Math.max(0, this.messageBuffer.length - messages.length));
+      this.lastL1At = Date.now();
+      setTimeout(() => this.distill("L2"), this.config.l2.delayAfterL1Seconds * 1e3);
+    } catch (e) {
+      errors.push(String(e));
+    }
+    return { stage: "L1", produced, errors };
+  }
+  async getLastSceneName() {
+    const recent = await this.store.searchL1("", 1);
+    return recent[0]?.sceneName || "\u65E0";
+  }
+  /**
+   * L2 Distillation: Cluster L1 memories into scene blocks
+   * (Reference: TDB's SceneExtractor)
+   */
+  async runL2Distillation() {
+    const errors = [];
+    let produced = 0;
+    try {
+      const now = Date.now();
+      if (this.lastL2At && now - this.lastL2At < this.config.l2.minIntervalMs) {
+        return { stage: "L2", produced: 0, errors: ["Too soon since last L2"] };
+      }
+      const l1Records = await this.store.searchL1("", 100);
+      if (l1Records.length < this.config.l2.topicThreshold) {
+        return { stage: "L2", produced: 0, errors: ["Not enough L1 records"] };
+      }
+      const sceneGroups = /* @__PURE__ */ new Map();
+      for (const record of l1Records) {
+        if (!sceneGroups.has(record.sceneName)) {
+          sceneGroups.set(record.sceneName, []);
+        }
+        sceneGroups.get(record.sceneName).push(record);
+      }
+      for (const [sceneName, records] of sceneGroups) {
+        if (records.length < this.config.l2.topicThreshold) continue;
+        const avgPriority = records.reduce((sum, r) => sum + r.priority, 0) / records.length;
+        const content = this.buildSceneContent(sceneName, records);
+        await this.store.storeL2({
+          title: sceneName,
+          content,
+          summary: `\u5E73\u5747\u4F18\u5148\u7EA7: ${avgPriority.toFixed(0)}`,
+          tags: [sceneName],
+          metadata: {
+            layer: "L2",
+            heat: records.length,
+            sourceRecords: records.map((r) => r.id)
+          }
+        });
+        produced++;
+      }
+      this.lastL2At = now;
+      setTimeout(() => this.distill("L3"), 5e3);
+    } catch (e) {
+      errors.push(String(e));
+    }
+    return { stage: "L2", produced, errors };
+  }
+  buildSceneContent(sceneName, records) {
+    const points = records.map((r) => `- [${r.type}] ${r.content}`).join("\n");
+    const avgPriority = records.reduce((sum, r) => sum + r.priority, 0) / records.length;
+    return `# ${sceneName}
+
+## Key Points
+${points}
+
+## Summary
+\u5E73\u5747\u4F18\u5148\u7EA7: ${avgPriority.toFixed(0)}
+\u5171 ${records.length} \u6761\u76F8\u5173\u8BB0\u5FC6
+
+---
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  }
+  /**
+   * L3 Distillation: Build persona from high-value scenes
+   * (Reference: TDB's PersonaExtractor)
+   */
+  async runL3Distillation() {
+    const errors = [];
+    let produced = 0;
+    try {
+      const l1Records = await this.store.searchL1("", 100);
+      if (l1Records.length === 0) {
+        return { stage: "L3", produced: 0, errors: ["No L1 records"] };
+      }
+      const avgImportance = l1Records.reduce((sum, r) => sum + r.priority, 0) / l1Records.length / 100;
+      if (avgImportance < this.config.l3.importanceThreshold) {
+        return { stage: "L3", produced: 0, errors: ["Avg importance below threshold"] };
+      }
+      const sceneIndex = await this.store.getSceneIndex();
+      const highValueScenes = sceneIndex.filter((s) => {
+        const avg = l1Records.filter((r) => r.sceneName === s.title).reduce((sum, r) => sum + r.priority, 0) / Math.max(1, l1Records.filter((r) => r.sceneName === s.title).length);
+        return avg >= this.config.l3.importanceThreshold * 100;
+      });
+      if (highValueScenes.length === 0) {
+        return { stage: "L3", produced: 0, errors: ["No high-value scenes"] };
+      }
+      const personaContent = this.buildPersona(highValueScenes, l1Records);
+      await this.store.storeL3({
+        content: personaContent,
+        summary: "Agent Self-Model",
+        metadata: {
+          layer: "L3",
+          sourceScenes: highValueScenes.map((s) => s.id)
+        }
+      });
+      produced = 1;
+      this.lastL3At = Date.now();
+    } catch (e) {
+      errors.push(String(e));
+    }
+    return { stage: "L3", produced, errors };
+  }
+  buildPersona(scenes, l1Records) {
+    const sceneContents = scenes.map((scene2) => {
+      const relatedMemories = l1Records.filter((r) => r.sceneName === scene2.title);
+      return `### ${scene2.title}
+${relatedMemories.map((m) => `- ${m.content}`).join("\n")}`;
+    }).join("\n\n");
+    const avgImportance = l1Records.reduce((sum, r) => sum + r.priority, 0) / l1Records.length / 100;
+    return `# Agent Self-Model
+
+## Core Knowledge
+${sceneContents}
+
+## Behavioral Patterns
+- \u5171 ${scenes.length} \u4E2A\u9AD8\u4EF7\u503C\u573A\u666F
+- \u5E73\u5747\u91CD\u8981\u6027: ${avgImportance.toFixed(2)}
+
+## Preferences
+(\u4ECE persona \u7C7B\u578B\u8BB0\u5FC6\u4E2D\u63D0\u53D6)
+
+## Communication Style
+(\u4ECE\u4EA4\u4E92\u6A21\u5F0F\u4E2D\u5B66\u4E60)
+
+---
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  fallbackExtract(messages, previousSceneName) {
+    const contents = messages.map((m) => m.content).join("\n");
+    const facts = [];
+    const patterns = [
+      /(?:decided|决定)(.+)/gi,
+      /(?:learned|学习)(.+)/gi,
+      /(?:remember|记住)(.+)/gi
+    ];
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(contents)) !== null) {
+        facts.push(match[1].trim());
+      }
+    }
+    if (facts.length === 0 && messages[0]) {
+      const content = messages[0].content;
+      if (content.length > 20) {
+        facts.push(content.slice(0, 100));
+      }
+    }
+    const sceneName = previousSceneName || "General";
+    return JSON.stringify([{
+      scene_name: sceneName,
+      memories: facts.slice(0, 3).map((content, i) => ({
+        content,
+        type: "episodic",
+        priority: 50 + i * 10,
+        source_message_ids: [messages[0]?.id || "unknown"],
+        metadata: {}
+      }))
+    }]);
+  }
+  checkTriggers() {
+    const now = Date.now();
+    return {
+      l1: this.messageBuffer.length >= this.config.l1.messageThreshold,
+      l2: this.lastL2At ? now - this.lastL2At >= this.config.l2.minIntervalMs : this.messageBuffer.length >= this.config.l2.topicThreshold,
+      l3: this.lastL3At === null
+    };
+  }
+  async getStats() {
+    const l1Records = await this.store.searchL1("", 1e3);
+    const l2Scenes = await this.store.getSceneIndex();
+    const persona = await this.store.getPersona();
+    return {
+      l0Count: this.messageBuffer.length,
+      l1Count: l1Records.length,
+      l2Count: l2Scenes.length,
+      l3Count: persona ? 1 : 0
+    };
+  }
+};
+function shouldExtractL1(content) {
+  if (content.length < 10) return false;
+  if (content.length > 1e4) return false;
+  return true;
+}
+function parseExtractionOutput(output) {
+  try {
+    const jsonMatch = output.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) {
+      const objMatch = output.match(/\{[\s\S]*\}/);
+      if (objMatch) {
+        return JSON.parse(objMatch[0]);
+      }
+      return [];
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (parsed.scene_name) {
+      return (parsed.memories || []).map((m) => ({
+        content: m.content,
+        type: normalizeMemoryType(m.type),
+        priority: Math.min(100, Math.max(0, Number(m.priority) || 50)),
+        source_message_ids: Array.isArray(m.source_message_ids) ? m.source_message_ids : [],
+        metadata: m.metadata || {},
+        scene_name: parsed.scene_name
+      }));
+    }
+    const memories = [];
+    for (const scene2 of parsed) {
+      for (const m of scene2.memories || []) {
+        memories.push({
+          content: m.content,
+          type: normalizeMemoryType(m.type),
+          priority: Math.min(100, Math.max(0, Number(m.priority) || 50)),
+          source_message_ids: Array.isArray(m.source_message_ids) ? m.source_message_ids : [],
+          metadata: m.metadata || {},
+          scene_name: scene2.scene_name
+        });
+      }
+    }
+    return memories;
+  } catch (e) {
+    console.error("Failed to parse LLM output:", e);
+    return [];
+  }
+}
+function normalizeMemoryType(type) {
+  const t = type?.toLowerCase();
+  if (t === "persona" || t === "episodic" || t === "instruction") {
+    return t;
+  }
+  return "episodic";
+}
+
+// index.ts
+var DEFAULT_CONFIG = {
+  enabled: true,
+  layersEnabled: { L0: true, L1: true, L2: true, L3: false },
+  decay: {
+    ttl: { enabled: true, retentionDays: 30, safetyThreshold: 0.8, minRetainL0: 50, minRetainL1: 20 },
+    importance: { enabled: true, baseHalflifeDays: 50 },
+    accessFrequency: { enabled: true },
+    stateMachine: { enabled: true }
+  },
+  teamMemory: {
+    enabled: true,
+    maxImportedAgents: 2,
+    visibilityGate: true
+  },
+  retrieval: {
+    hybridSearch: true,
+    semanticWeight: 0.5,
+    bm25Weight: 0.25,
+    entityBoostWeight: 0.25,
+    topK: 10,
+    overFetch: 4
+  },
+  storage: {
+    backend: "memory",
+    dataDir: "~/.openclaw/memory-new"
+  },
+  llm: {
+    enabled: false,
+    // Disabled by default, use fallback extraction
+    model: "default"
+  }
+};
+function deriveFreshness(engram, config) {
+  if (!config.decay.importance.enabled) return "fresh";
+  const ageDays = (Date.now() - engram.lastEffectiveAt) / (1e3 * 60 * 60 * 24);
+  const halflife = config.decay.importance.baseHalflifeDays * Math.pow(engram.importance + 0.1, 1.5);
+  if (ageDays <= halflife) return "fresh";
+  if (ageDays <= halflife * 2) return "aging";
+  if (ageDays <= halflife * 4) return "stale";
+  return "forgotten";
+}
+function deriveHotness(retrievalCount, ageDays) {
+  return 1 / (1 + Math.exp(-Math.log(1 + retrievalCount))) * Math.exp(-Math.LN2 * ageDays / 7);
+}
+function calculateScore(relevance, recency, importance, strength, hotness, weights = { relevance: 0.5, recency: 0.15, importance: 0.25, strength: 0.05, hotness: 0.05 }) {
+  return weights.relevance * relevance + weights.recency * recency + weights.importance * importance + weights.strength * strength + weights.hotness * hotness;
+}
+function validateVisibilityTransition(from, to, config) {
+  if (!config.teamMemory.visibilityGate) return true;
+  if (from === to) return true;
+  if (to === "private" && from !== "private") return false;
+  if (from === "private") return true;
+  return true;
+}
 var index_default = definePluginEntry({
   id: "memory_new",
   name: "Memory New",
-  description: "A new memory extension for OpenClaw.",
+  description: "Multi-layered memory system with L0\u2192L1\u2192L2\u2192L3 distillation, persistent storage, and recall",
   register(api) {
-    const config = api.pluginConfig ?? { enabled: true };
+    const config = api.pluginConfig ?? DEFAULT_CONFIG;
+    const storage = new StorageAdapter(config.storage.dataDir);
+    const store = new MemoryStore(config.storage.dataDir);
+    const recall = new RecallEngine(storage);
+    const vectorStore = new VectorStore();
+    const pipeline = new DistillationPipeline(DEFAULT_DISTILLATION_CONFIG, store, vectorStore);
+    store.setVectorStore(vectorStore);
+    if (config.llm?.enabled) {
+      api.registerEmbeddingProvider({
+        id: "memory-new-embedder",
+        defaultModel: config.llm.model ?? "default",
+        transport: "local",
+        create: async (options) => {
+          const provider = {
+            id: "memory-new-embedder",
+            model: options.model,
+            dimensions: 384,
+            maxInputTokens: 8192,
+            embed: async (input) => {
+              const text = typeof input === "string" ? input : input.text;
+              return vectorStore.generatePseudoEmbedding(text);
+            },
+            embedBatch: async (inputs) => {
+              return inputs.map((input) => {
+                const text = typeof input === "string" ? input : input.text;
+                return vectorStore.generatePseudoEmbedding(text);
+              });
+            }
+          };
+          return { provider, runtime: { id: "memory-new-embedder" } };
+        }
+      });
+      pipeline.setSubagentRunner(async (prompt) => {
+        try {
+          const result = await api.runtime.subagent.run({
+            sessionKey: `memory-${Date.now()}`,
+            message: prompt,
+            model: config.llm?.model,
+            disableTools: true
+          });
+          const waitResult = await api.runtime.subagent.waitForRun({ runId: result.runId, timeoutMs: 3e4 });
+          const messages = await api.runtime.subagent.getSessionMessages({ sessionKey: result.sessionKey });
+          const assistantMsg = messages.messages.find((m) => m.role === "assistant");
+          return assistantMsg?.content?.[0]?.text ?? "";
+        } catch (error) {
+          api.logger.debug?.(`Subagent extraction failed: ${error}`);
+          throw error;
+        }
+      });
+    }
+    const sessionMessages = /* @__PURE__ */ new Map();
     api.registerCommand({
-      name: "memory_new",
-      description: "Interact with Memory New extension.",
+      name: "memory",
+      description: "Interact with memory system",
       acceptsArgs: true,
       exposeSenderIsOwner: true,
       handler: async (ctx) => {
-        const tokens = ctx.args?.trim().split(/\s+/).filter(Boolean) ?? [];
-        const action = (tokens[0] ?? "status").toLowerCase();
-        if (action === "status") {
-          return {
-            text: `Memory New: ${config.enabled ? "enabled" : "disabled"}`
-          };
+        const args = ctx.args ?? "";
+        const [action, ...rest] = args.trim().split(/\s+/);
+        switch (action) {
+          case "add": {
+            const content = rest.join(" ");
+            if (!content) return { text: "Usage: memory add <content>" };
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            await store.storeL1({
+              content,
+              type: "episodic",
+              priority: 50,
+              sceneName: "User Added",
+              sourceMessageIds: [],
+              metadata: { source: "command" },
+              timestamps: [now],
+              sessionKey: ctx.sessionKey ?? "default",
+              sessionId: ctx.sessionKey ?? "default",
+              userId: ctx.senderIsOwner ? "owner" : "user",
+              agentId: "self"
+            });
+            return { text: `Added: ${content.slice(0, 50)}...` };
+          }
+          case "search": {
+            const query = rest.join(" ");
+            if (!query) return { text: "Usage: memory search <query>" };
+            const result = await recall.recall({
+              query,
+              sessionKey: ctx.sessionKey ?? "default",
+              userId: ctx.senderIsOwner ? "owner" : "user",
+              agentId: "self",
+              topK: config.retrieval.topK
+            });
+            if (!result.prependContext && !result.appendSystemContext) {
+              return { text: "No relevant memories found." };
+            }
+            return {
+              text: `Found memories:
+
+${result.prependContext ?? ""}
+
+${result.appendSystemContext ?? ""}`
+            };
+          }
+          case "list": {
+            const records = await store.searchL1("", 20);
+            if (records.length === 0) return { text: "No memories stored." };
+            const lines = records.map(
+              (r) => `[${r.type}] ${r.content.slice(0, 60)}${r.content.length > 60 ? "..." : ""}`
+            );
+            return { text: `Recent ${records.length} memories:
+
+${lines.join("\n")}` };
+          }
+          case "reinforce": {
+            return { text: "Reinforce is not yet supported with persistent storage." };
+          }
+          case "decay": {
+            return { text: "Decay is not yet fully implemented." };
+          }
+          case "stats": {
+            const stats = await pipeline.getStats();
+            return {
+              text: `Memory Stats:
+  L0 (buffered): ${stats.l0Count}
+  L1 (stored): ${stats.l1Count}
+  L2 (scenes): ${stats.l2Count}
+  L3 (persona): ${stats.l3Count}`
+            };
+          }
+          case "config": {
+            return { text: JSON.stringify(config, null, 2) };
+          }
+          default:
+            return {
+              text: `Memory New commands:
+  memory add <content>       - Add a memory
+  memory search <query>     - Search memories
+  memory list               - List recent memories
+  memory stats              - Show memory statistics
+  memory config             - Show configuration
+
+Memory layers: L0 (raw) \u2192 L1 (atomic) \u2192 L2 (scene) \u2192 L3 (persona)`
+            };
         }
-        if (action === "help") {
-          return {
-            text: `Memory New Commands:
-  status - Show current status
-  help - Show this help`
-          };
+      }
+    });
+    api.registerCommand({
+      name: "team-memory",
+      description: "Team memory operations",
+      acceptsArgs: true,
+      exposeSenderIsOwner: true,
+      handler: async (ctx) => {
+        if (!config.teamMemory.enabled) {
+          return { text: "Team memory is disabled." };
+        }
+        const args = ctx.args ?? "";
+        const [action, ...rest] = args.trim().split(/\s+/);
+        switch (action) {
+          case "share": {
+            return { text: "Share is not yet implemented." };
+          }
+          case "import": {
+            return { text: "Import is not yet implemented." };
+          }
+          case "status": {
+            const stats = await pipeline.getStats();
+            return {
+              text: `Team memory status:
+  Enabled: ${config.teamMemory.enabled}
+  Max imported agents: ${config.teamMemory.maxImportedAgents}
+  Visibility gate: ${config.teamMemory.visibilityGate}
+  Total L1 memories: ${stats.l1Count}
+  Total L2 scenes: ${stats.l2Count}`
+            };
+          }
+          default:
+            return {
+              text: `Team memory commands:
+  team-memory status            - Show team memory status`
+            };
         }
-        return {
-          text: `Unknown action: ${action}
-
-Type "memory_new help" for available commands.`
-        };
       }
     });
     api.on("before_prompt_build", async (event, ctx) => {
-      if (!config.enabled) {
+      if (!config.enabled) return void 0;
+      const sessionKey = ctx.sessionKey ?? "default";
+      const userId = "user";
+      try {
+        const query = event.prompt?.slice(0, 200) ?? "";
+        const recallResult = await recall.recall({
+          query,
+          sessionKey,
+          userId,
+          agentId: "self",
+          topK: config.retrieval.topK,
+          vectorStore: config.retrieval.hybridSearch ? vectorStore : void 0
+        });
+        if (!recallResult.prependContext && !recallResult.appendSystemContext) {
+          return void 0;
+        }
+        return {
+          prependContext: recallResult.prependContext,
+          appendContext: recallResult.appendSystemContext
+        };
+      } catch (error) {
+        api.logger.debug?.(`Memory recall failed: ${error}`);
         return void 0;
       }
-      api.logger.info?.("memory_new: before_prompt_build triggered");
-      return {
-        prependContext: "[Memory New Plugin] Memory New plugin is active."
-      };
+    });
+    api.on("after_prompt_build", async (event, ctx) => {
+      if (!config.enabled || !config.layersEnabled.L0) return;
+      const sessionKey = ctx.sessionKey ?? "default";
+      try {
+        const messages = event.messages ?? [];
+        if (messages.length > 0) {
+          for (const msg of messages) {
+            const l0Msg = {
+              role: msg.role === "user" ? "user" : "assistant",
+              content: msg.content?.slice(0, 1e4) ?? "",
+              // Limit length
+              timestamp: msg.timestamp ?? Date.now(),
+              sessionKey,
+              sessionId: sessionKey,
+              userId: "user",
+              agentId: "self"
+            };
+            await store.ingestMessage(l0Msg);
+          }
+          if (config.layersEnabled.L1 && config.llm?.enabled) {
+            await pipeline.distill("L1");
+          }
+        }
+      } catch (error) {
+        api.logger.debug?.(`Memory capture failed: ${error}`);
+      }
     });
     api.on("agent_end", (event, ctx) => {
+      if (!config.enabled) return;
       const runId = event.runId ?? ctx.runId;
-      api.logger.debug?.(`memory_new: agent_end for run ${runId}`);
+      api.logger.debug?.(`Memory: agent ended for run ${runId}`);
+    });
+    api.on("session_end", async (event, ctx) => {
+      if (!config.enabled) return;
+      const sessionKey = ctx.sessionKey ?? "default";
+      try {
+        if (config.layersEnabled.L2) {
+          await pipeline.distill("L2");
+        }
+        if (config.layersEnabled.L3) {
+          await pipeline.distill("L3");
+        }
+        sessionMessages.delete(sessionKey);
+        api.logger.debug?.(`Memory: session ended for ${sessionKey}`);
+      } catch (error) {
+        api.logger.debug?.(`Memory session cleanup failed: ${error}`);
+      }
+    });
+    api.registerTool({
+      name: "memory_search",
+      description: "Search memory store using hybrid retrieval",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          limit: { type: "number", description: "Max results", default: 10 },
+          visibility: {
+            type: "string",
+            enum: ["all", "public", "team", "private"],
+            default: "all"
+          }
+        },
+        required: ["query"]
+      },
+      execute: async (params, ctx) => {
+        const result = await recall.recall({
+          query: params.query,
+          sessionKey: ctx.sessionKey ?? "default",
+          userId: "user",
+          agentId: "self",
+          topK: params.limit ?? 10
+        });
+        return {
+          memories: result.recalledL1Memories ?? [],
+          prependContext: result.prependContext,
+          appendContext: result.appendSystemContext
+        };
+      }
+    });
+    api.registerTool({
+      name: "memory_store",
+      description: "Store a new memory engram",
+      parameters: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "Memory content" },
+          type: {
+            type: "string",
+            enum: ["persona", "episodic", "instruction"],
+            default: "episodic",
+            description: "Memory type"
+          },
+          priority: {
+            type: "number",
+            default: 50,
+            description: "Priority 0-100"
+          },
+          sceneName: {
+            type: "string",
+            default: "General",
+            description: "Scene name"
+          }
+        },
+        required: ["content"]
+      },
+      execute: async (params, ctx) => {
+        const record = await store.storeL1({
+          content: params.content,
+          type: params.type ?? "episodic",
+          priority: params.priority ?? 50,
+          sceneName: params.sceneName ?? "General",
+          sourceMessageIds: [],
+          metadata: { source: "tool" },
+          timestamps: [(/* @__PURE__ */ new Date()).toISOString()],
+          sessionKey: ctx.sessionKey ?? "default",
+          sessionId: ctx.sessionKey ?? "default",
+          userId: "user",
+          agentId: "self"
+        });
+        return { engramId: record.id, stored: true };
+      }
+    });
+    api.registerTool({
+      name: "memory_get",
+      description: "Get a specific memory by ID",
+      parameters: {
+        type: "object",
+        properties: {
+          layer: {
+            type: "string",
+            enum: ["L0", "L1", "L2", "L3"],
+            default: "L1",
+            description: "Memory layer"
+          },
+          id: { type: "string", description: "Memory ID (for L2/L3)" }
+        },
+        required: []
+      },
+      execute: async (params, ctx) => {
+        if (params.layer === "L2" && params.id) {
+          const scene2 = await store.getScene(params.id);
+          return scene2 ?? { error: "Scene not found" };
+        }
+        if (params.layer === "L3") {
+          const persona = await store.getPersona();
+          return persona ?? { error: "Persona not found" };
+        }
+        const records = await store.searchL1("", 10);
+        return { records };
+      }
+    });
+    api.registerTool({
+      name: "memory_distill",
+      description: "Trigger memory distillation manually",
+      parameters: {
+        type: "object",
+        properties: {
+          layer: {
+            type: "string",
+            enum: ["L1", "L2", "L3"],
+            default: "L1",
+            description: "Layer to distill"
+          }
+        },
+        required: ["layer"]
+      },
+      execute: async (params, ctx) => {
+        const layer = params.layer;
+        const result = await pipeline.distill(layer);
+        return {
+          layer: result.stage,
+          produced: result.produced,
+          errors: result.errors
+        };
+      }
+    });
+    api.registerHttpRoute({
+      method: "GET",
+      path: "/memory/team/status",
+      handler: async (req, ctx) => {
+        if (!config.teamMemory.enabled) {
+          return { status: 403, body: { error: "Team memory disabled" } };
+        }
+        const stats = await pipeline.getStats();
+        return {
+          status: 200,
+          body: {
+            enabled: true,
+            maxImportedAgents: config.teamMemory.maxImportedAgents,
+            l1Count: stats.l1Count,
+            l2Count: stats.l2Count
+          }
+        };
+      }
+    });
+    api.registerHttpRoute({
+      method: "POST",
+      path: "/memory/team/share",
+      handler: async (req, ctx) => {
+        if (!config.teamMemory.enabled) {
+          return { status: 403, body: { error: "Team memory disabled" } };
+        }
+        return { status: 501, body: { error: "Not implemented" } };
+      }
+    });
+    api.registerHttpRoute({
+      method: "POST",
+      path: "/memory/team/import",
+      handler: async (req, ctx) => {
+        if (!config.teamMemory.enabled) {
+          return { status: 403, body: { error: "Team memory disabled" } };
+        }
+        return { status: 501, body: { error: "Not implemented" } };
+      }
+    });
+    api.logger.info?.("Memory New plugin registered with storage and pipeline");
+    api.registerConfigMigration?.({
+      id: "memory-new-default-config",
+      migrate: (existingConfig) => {
+        const current = existingConfig?.memory_new;
+        if (!current) {
+          return {
+            memory_new: {
+              enabled: true,
+              layersEnabled: { L0: true, L1: true, L2: true, L3: false },
+              llm: { enabled: false, model: "default" },
+              retrieval: {
+                hybridSearch: true,
+                semanticWeight: 0.5,
+                bm25Weight: 0.25,
+                entityBoostWeight: 0.25,
+                topK: 10,
+                overFetch: 4
+              },
+              storage: { backend: "memory", dataDir: "~/.openclaw/memory-new" },
+              decay: {
+                ttl: { enabled: true, retentionDays: 30, safetyThreshold: 0.8, minRetainL0: 50, minRetainL1: 20 },
+                importance: { enabled: true, baseHalflifeDays: 50 },
+                accessFrequency: { enabled: true },
+                stateMachine: { enabled: true }
+              },
+              teamMemory: { enabled: true, maxImportedAgents: 2, visibilityGate: true }
+            }
+          };
+        }
+        return {};
+      }
+    });
+    api.registerAutoEnableProbe?.({
+      id: "memory-new",
+      check: async (config2) => {
+        const hasConfig = config2?.plugins?.memory_new?.enabled === true;
+        const hasStorageDir = false;
+        return hasConfig || hasStorageDir;
+      }
     });
   }
 });
-var testing = {};
+var testing = {
+  deriveFreshness,
+  deriveHotness,
+  calculateScore,
+  validateVisibilityTransition
+};
 export {
   index_default as default,
   testing