@cc-soul/openclaw 1.0.0

package/cc-soul/memory.js

@@ -0,0 +1,688 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { MEMORIES_PATH, HISTORY_PATH, loadJson, debouncedSave } from "./persistence.ts";
+import { spawnCLI } from "./cli.ts";
+function shuffleArray(arr) {
+  const result = [...arr];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+__name(shuffleArray, "shuffleArray");
+const memoryState = {
+  memories: [],
+  chatHistory: []
+};
+const MAX_MEMORIES = 1e4;
+const MAX_HISTORY = 100;
+const INJECT_HISTORY = 30;
+function addToHistory(user, assistant) {
+  memoryState.chatHistory.push({
+    user: user.slice(0, 1e3),
+    assistant: assistant.slice(0, 2e3),
+    ts: Date.now()
+  });
+  if (memoryState.chatHistory.length > MAX_HISTORY) {
+    const trimmed = memoryState.chatHistory.slice(-MAX_HISTORY);
+    memoryState.chatHistory.length = 0;
+    memoryState.chatHistory.push(...trimmed);
+  }
+  debouncedSave(HISTORY_PATH, memoryState.chatHistory);
+}
+__name(addToHistory, "addToHistory");
+function buildHistoryContext() {
+  if (memoryState.chatHistory.length === 0) return "";
+  const recent = memoryState.chatHistory.slice(-INJECT_HISTORY);
+  const lines = recent.map((t) => {
+    const timeStr = new Date(t.ts).toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
+    return `[${timeStr}] \u7528\u6237: ${t.user}
+\u52A9\u624B: ${t.assistant}`;
+  }).join("\n\n");
+  return `[\u5BF9\u8BDD\u5386\u53F2\uFF08\u6700\u8FD1${recent.length}\u8F6E\uFF09]
+${lines}`;
+}
+__name(buildHistoryContext, "buildHistoryContext");
+function tagMemoryAsync(memIndex, content) {
+  const safeContent = content.slice(0, 200).replace(/"/g, '\\"').replace(/\n/g, " ");
+  spawnCLI(
+    `\u4E3A\u4EE5\u4E0B\u5185\u5BB9\u751F\u621010-15\u4E2A\u8BED\u4E49\u6807\u7B7E\uFF0C\u8981\u6C42\uFF1A
+1. \u5305\u542B\u539F\u6587\u5173\u952E\u8BCD
+2. \u5305\u542B\u540C\u4E49\u8BCD\uFF08\u5982"dyld"\u2192\u4E5F\u52A0"\u52A8\u6001\u94FE\u63A5\u5668","mach-o"\u2192\u4E5F\u52A0"\u4E8C\u8FDB\u5236"\uFF09
+3. \u5305\u542B\u4E0A\u4F4D\u6982\u5FF5\uFF08\u5982"python flask"\u2192\u4E5F\u52A0"web\u6846\u67B6","\u540E\u7AEF"\uFF09
+4. \u4E2D\u82F1\u6587\u90FD\u8981
+\u9017\u53F7\u5206\u9694\uFF0C\u53EA\u8F93\u51FA\u6807\u7B7E\uFF1A
+"${safeContent}"`,
+    (output) => {
+      if (!output) return;
+      const tags = output.split(/[,，]/).map((t) => t.trim().toLowerCase().replace(/^[#\s]+/, "")).filter((t) => t.length >= 2 && t.length <= 20);
+      if (tags.length >= 3 && memIndex < memoryState.memories.length) {
+        memoryState.memories[memIndex].tags = tags;
+        saveMemories();
+        console.log(`[cc-soul][tags] tagged mem[${memIndex}]: [${tags.join(", ")}]`);
+      }
+    }
+  );
+}
+__name(tagMemoryAsync, "tagMemoryAsync");
+function batchTagUntaggedMemories() {
+  const untagged = memoryState.memories.map((m, i) => ({ m, i })).filter(({ m }) => !m.tags || m.tags.length === 0).slice(0, 5);
+  if (untagged.length === 0) return;
+  console.log(`[cc-soul][tags] batch tagging ${untagged.length} untagged memories`);
+  let delay = 0;
+  for (const { m, i } of untagged) {
+    setTimeout(() => tagMemoryAsync(i, m.content), delay);
+    delay += 1e4;
+  }
+}
+__name(batchTagUntaggedMemories, "batchTagUntaggedMemories");
+function loadMemories() {
+  const loaded = loadJson(MEMORIES_PATH, []);
+  memoryState.memories.length = 0;
+  memoryState.memories.push(...loaded);
+  const loadedHistory = loadJson(HISTORY_PATH, []);
+  memoryState.chatHistory.length = 0;
+  memoryState.chatHistory.push(...loadedHistory);
+}
+__name(loadMemories, "loadMemories");
+function saveMemories() {
+  debouncedSave(MEMORIES_PATH, memoryState.memories);
+}
+__name(saveMemories, "saveMemories");
+function defaultVisibility(scope) {
+  if (scope === "fact" || scope === "discovery") return "global";
+  if (scope === "correction" || scope === "preference") return "channel";
+  if (scope === "proactive" || scope === "curiosity" || scope === "reflection") return "private";
+  return "channel";
+}
+__name(defaultVisibility, "defaultVisibility");
+function addMemory(content, scope, userId, visibility, channelId) {
+  if (!content || content.length < 3) return;
+  const isDup = memoryState.memories.some(
+    (m) => m.scope === scope && (m.content === content || m.content.length > 10 && content.includes(m.content.slice(0, 20)))
+  );
+  if (isDup) return;
+  const resolvedVisibility = visibility || defaultVisibility(scope);
+  const newIndex = memoryState.memories.length;
+  memoryState.memories.push({ content, scope, ts: Date.now(), userId, visibility: resolvedVisibility, channelId });
+  if (memoryState.memories.length > MAX_MEMORIES) {
+    const trimmed = memoryState.memories.slice(-Math.floor(MAX_MEMORIES * 0.8));
+    memoryState.memories.length = 0;
+    memoryState.memories.push(...trimmed);
+  }
+  invalidateIDF();
+  saveMemories();
+  if (content.length > 10) {
+    const lastIdx = memoryState.memories.length - 1;
+    if (lastIdx >= 0 && memoryState.memories[lastIdx].content === content && !memoryState.memories[lastIdx].tags) {
+      tagMemoryAsync(lastIdx, content);
+    }
+  }
+}
+__name(addMemory, "addMemory");
+function addMemoryWithEmotion(content, scope, userId, visibility, channelId, emotion) {
+  addMemory(content, scope, userId, visibility, channelId);
+  if (emotion) {
+    const validEmotions = ["neutral", "warm", "important", "painful", "funny"];
+    const matched = validEmotions.find((e) => emotion.includes(e)) || "neutral";
+    const idx = memoryState.memories.findIndex((m) => m.content === content);
+    if (idx >= 0) {
+      memoryState.memories[idx].emotion = matched;
+      saveMemories();
+    }
+  } else if (content.length > 20) {
+    spawnCLI(
+      `\u8FD9\u6761\u8BB0\u5FC6\u7684\u60C5\u611F\u6743\u91CD\uFF1F"${content.slice(0, 100)}" \u56DE\u7B54: neutral/warm/important/painful/funny \u53EA\u56DE\u4E00\u4E2A\u8BCD`,
+      (output) => {
+        const emotion2 = output?.trim().toLowerCase() || "neutral";
+        const validEmotions = ["neutral", "warm", "important", "painful", "funny"];
+        const matched = validEmotions.find((e) => emotion2.includes(e)) || "neutral";
+        const idx = memoryState.memories.findIndex((m) => m.content === content);
+        if (idx >= 0) {
+          memoryState.memories[idx].emotion = matched;
+          saveMemories();
+        }
+      }
+    );
+  }
+}
+__name(addMemoryWithEmotion, "addMemoryWithEmotion");
+let idfCache = null;
+function buildIDF() {
+  if (idfCache && idfCache.size > 0) return idfCache;
+  const df = /* @__PURE__ */ new Map();
+  const N = memoryState.memories.length || 1;
+  for (const mem of memoryState.memories) {
+    const words = new Set((mem.content.match(/[\u4e00-\u9fff]{2,}|[a-z]{3,}/gi) || []).map((w) => w.toLowerCase()));
+    for (const w of words) {
+      df.set(w, (df.get(w) || 0) + 1);
+    }
+  }
+  const idf = /* @__PURE__ */ new Map();
+  for (const [word, count] of df) {
+    idf.set(word, Math.log(N / (1 + count)));
+  }
+  idfCache = idf;
+  return idf;
+}
+__name(buildIDF, "buildIDF");
+function tfidfVector(text, idf) {
+  const words = (text.match(/[\u4e00-\u9fff]{2,}|[a-z]{3,}/gi) || []).map((w) => w.toLowerCase());
+  const tf = /* @__PURE__ */ new Map();
+  for (const w of words) {
+    tf.set(w, (tf.get(w) || 0) + 1);
+  }
+  const vec = /* @__PURE__ */ new Map();
+  for (const [word, count] of tf) {
+    const idfVal = idf.get(word) || 1;
+    vec.set(word, count / words.length * idfVal);
+  }
+  return vec;
+}
+__name(tfidfVector, "tfidfVector");
+function cosineSim(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (const [word, val] of a) {
+    const bVal = b.get(word) || 0;
+    dot += val * bVal;
+    normA += val * val;
+  }
+  for (const [, val] of b) {
+    normB += val * val;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+__name(cosineSim, "cosineSim");
+function recall(msg, topN = 3, userId, channelId) {
+  if (memoryState.memories.length === 0 || !msg) return [];
+  const queryWords = new Set(
+    (msg.match(/[\u4e00-\u9fff]{2,}|[a-z]{3,}/gi) || []).map((w) => w.toLowerCase())
+  );
+  if (queryWords.size === 0) return [];
+  let idf = null;
+  const scored = [];
+  for (const mem of memoryState.memories) {
+    const vis = mem.visibility || "global";
+    if (vis === "channel" && channelId && mem.channelId && mem.channelId !== channelId) continue;
+    if (vis === "private" && userId && mem.userId && mem.userId !== userId) continue;
+    let sim = 0;
+    if (mem.tags && mem.tags.length > 0) {
+      let hits = 0;
+      for (const qw of queryWords) {
+        for (const tag of mem.tags) {
+          if (tag.includes(qw) || qw.includes(tag)) {
+            hits += 1;
+            break;
+          }
+        }
+      }
+      sim = hits / Math.max(1, queryWords.size);
+    } else {
+      if (!idf) idf = buildIDF();
+      const queryVec = tfidfVector(msg, idf);
+      const memVec = tfidfVector(mem.content, idf);
+      sim = cosineSim(queryVec, memVec);
+    }
+    if (sim < 0.05) continue;
+    const ageDays = mem.ts > 0 ? (Date.now() - mem.ts) / 864e5 : 30;
+    const recency = 1 / (1 + ageDays * 0.03);
+    const scopeBoost = mem.scope === "preference" || mem.scope === "fact" ? 1.3 : mem.scope === "correction" ? 1.5 : 1;
+    const emotionBoost = mem.emotion === "important" ? 1.4 : mem.emotion === "painful" ? 1.3 : mem.emotion === "warm" ? 1.2 : 1;
+    const userBoost = userId && mem.userId && mem.userId === userId ? 1.3 : 1;
+    const consolidatedBoost = mem.scope === "consolidated" ? 1.5 : 1;
+    scored.push({ ...mem, score: sim * recency * scopeBoost * emotionBoost * userBoost * consolidatedBoost });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, topN);
+}
+__name(recall, "recall");
+function invalidateIDF() {
+  idfCache = null;
+}
+__name(invalidateIDF, "invalidateIDF");
+function consolidateFragments() {
+  if (memoryState.memories.length === 0) return "";
+  const prefs = memoryState.memories.filter((m) => m.scope === "preference").slice(-5);
+  const facts = memoryState.memories.filter((m) => m.scope === "fact").slice(-5);
+  const recent = memoryState.memories.filter((m) => m.scope === "topic").slice(-10);
+  const parts = [];
+  if (facts.length) parts.push("\u5DF2\u77E5: " + facts.map((f) => f.content).join("; "));
+  if (prefs.length) parts.push("\u504F\u597D: " + prefs.map((p) => p.content).join("; "));
+  if (recent.length) {
+    const topics = [...new Set(recent.map((r) => r.content.replace("\u8BDD\u9898: ", "")))].slice(-5);
+    parts.push("\u8FD1\u671F\u8BDD\u9898: " + topics.join(", "));
+  }
+  const emotional = memoryState.memories.filter((m) => m.emotion && m.emotion !== "neutral").slice(-5);
+  if (emotional.length) {
+    parts.push("\u5370\u8C61\u6DF1\u523B: " + emotional.map((m) => `${m.content} (${m.emotion})`).join("; "));
+  }
+  const dreams = memoryState.memories.filter((m) => m.scope === "dream").slice(-3);
+  if (dreams.length) {
+    parts.push("\u68A6\u5883\u6D1E\u5BDF: " + dreams.map((d) => d.content).join("; "));
+  }
+  const curiosities = memoryState.memories.filter((m) => m.scope === "curiosity").slice(-3);
+  if (curiosities.length) {
+    parts.push("\u597D\u5947: " + curiosities.map((c) => c.content).join("; "));
+  }
+  return parts.join("\n");
+}
+__name(consolidateFragments, "consolidateFragments");
+let lastConsolidationTs = 0;
+const CONSOLIDATION_COOLDOWN_MS = 24 * 3600 * 1e3;
+function consolidateMemories() {
+  if (memoryState.memories.length < 500) return;
+  if (Date.now() - lastConsolidationTs < CONSOLIDATION_COOLDOWN_MS) return;
+  lastConsolidationTs = Date.now();
+  const groups = /* @__PURE__ */ new Map();
+  for (const mem of memoryState.memories) {
+    const key = mem.scope || "unknown";
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(mem);
+  }
+  for (const [scope, mems] of groups) {
+    if (mems.length < 50) continue;
+    if (scope === "consolidated") continue;
+    const oldest = mems.sort((a, b) => a.ts - b.ts).slice(0, 20);
+    const contents = oldest.map((m) => m.content).join("\n");
+    spawnCLI(
+      `\u4EE5\u4E0B\u662F${scope}\u7C7B\u578B\u7684${oldest.length}\u6761\u8BB0\u5FC6\uFF0C\u8BF7\u5408\u5E76\u4E3A1-3\u6761\u6458\u8981\uFF08\u4FDD\u7559\u5173\u952E\u4FE1\u606F\uFF09\uFF1A
+
+${contents.slice(0, 1500)}
+
+\u683C\u5F0F\uFF1A\u6BCF\u6761\u6458\u8981\u4E00\u884C`,
+      (output) => {
+        if (!output || output.length < 10) return;
+        const summaries = output.split("\n").filter((l) => l.trim().length > 5).slice(0, 3);
+        const indicesToDelete = oldest.map((old) => memoryState.memories.findIndex((m) => m.content === old.content && m.ts === old.ts)).filter((idx) => idx >= 0).sort((a, b) => b - a);
+        for (const idx of indicesToDelete) {
+          memoryState.memories.splice(idx, 1);
+        }
+        for (const summary of summaries) {
+          memoryState.memories.push({
+            content: summary.trim(),
+            scope: "consolidated",
+            ts: Date.now(),
+            visibility: oldest[0]?.visibility || "global"
+          });
+        }
+        saveMemories();
+        invalidateIDF();
+        console.log(`[cc-soul][memory] consolidated ${oldest.length} ${scope} memories -> ${summaries.length} summaries`);
+      }
+    );
+  }
+}
+__name(consolidateMemories, "consolidateMemories");
+let lastRecallFeedbackTs = 0;
+const RECALL_FEEDBACK_COOLDOWN = 6e4;
+function recallFeedbackLoop(userMsg, recalledContents) {
+  const now = Date.now();
+  if (now - lastRecallFeedbackTs < RECALL_FEEDBACK_COOLDOWN) return;
+  if (memoryState.memories.length < 20) return;
+  if (userMsg.length < 10) return;
+  lastRecallFeedbackTs = now;
+  const recalledSet = new Set(recalledContents);
+  const candidates = shuffleArray(memoryState.memories.filter((m) => !recalledSet.has(m.content) && m.content.length > 15)).slice(0, 20);
+  if (candidates.length === 0) return;
+  const candidateList = candidates.map((m, i) => `${i + 1}. [${m.scope}] ${m.content.slice(0, 80)}`).join("\n");
+  const recalledList = recalledContents.length > 0 ? recalledContents.map((c) => c.slice(0, 60)).join("; ") : "(\u65E0)";
+  spawnCLI(
+    `\u7528\u6237\u95EE\u4E86: "${userMsg.slice(0, 200)}"
+\u7CFB\u7EDF\u53EC\u56DE\u4E86: ${recalledList}
+
+\u4EE5\u4E0B\u662F\u672A\u88AB\u53EC\u56DE\u7684\u8BB0\u5FC6\uFF0C\u54EA\u4E9B\u5176\u5B9E\u548C\u7528\u6237\u7684\u95EE\u9898\u76F8\u5173\uFF1F
+${candidateList}
+
+\u53EA\u8F93\u51FA\u76F8\u5173\u8BB0\u5FC6\u7684\u7F16\u53F7\uFF08\u9017\u53F7\u5206\u9694\uFF09\uFF0C\u5982\u679C\u90FD\u4E0D\u76F8\u5173\u5C31\u56DE\u7B54"\u65E0"`,
+    (output) => {
+      if (!output || output.includes("\u65E0")) return;
+      const nums = output.match(/\d+/g)?.map(Number) || [];
+      const queryWords = (userMsg.match(/[\u4e00-\u9fff]{2,}|[a-z]{3,}/gi) || []).map((w) => w.toLowerCase()).slice(0, 8);
+      let patched = 0;
+      for (const num of nums) {
+        const idx = num - 1;
+        if (idx < 0 || idx >= candidates.length) continue;
+        const mem = candidates[idx];
+        const memIdx = memoryState.memories.findIndex((m) => m.content === mem.content && m.ts === mem.ts);
+        if (memIdx < 0) continue;
+        if (!mem.tags) mem.tags = [];
+        for (const w of queryWords) {
+          if (!mem.tags.includes(w)) {
+            mem.tags.push(w);
+          }
+        }
+        if (mem.tags.length > 25) mem.tags = mem.tags.slice(-25);
+        patched++;
+      }
+      if (patched > 0) {
+        saveMemories();
+        console.log(`[cc-soul][recall-feedback] patched ${patched} memories with cross-tags from query`);
+      }
+    }
+  );
+}
+__name(recallFeedbackLoop, "recallFeedbackLoop");
+let cachedAssociation = null;
+const ASSOCIATION_COOLDOWN = 3e4;
+function triggerAssociativeRecall(userMsg, topRecalled) {
+  if (userMsg.length < 10) return;
+  if (cachedAssociation && Date.now() - cachedAssociation.ts < ASSOCIATION_COOLDOWN) return;
+  const recalledSet = new Set(topRecalled);
+  const pool = shuffleArray(memoryState.memories.filter((m) => !recalledSet.has(m.content) && m.content.length > 15 && m.scope !== "proactive")).slice(0, 30);
+  if (pool.length < 5) return;
+  const memList = pool.map((m, i) => `${i + 1}. ${m.content.slice(0, 80)}`).join("\n");
+  spawnCLI(
+    `\u7528\u6237\u8BF4: "${userMsg.slice(0, 200)}"
+
+\u4EE5\u4E0B\u662F\u4E00\u4E9B\u5386\u53F2\u8BB0\u5FC6\uFF0C\u54EA\u4E9B\u548C\u7528\u6237\u5F53\u524D\u7684\u8BDD\u9898\u6709\u9690\u542B\u5173\u8054\uFF1F\uFF08\u4E0D\u662F\u5B57\u9762\u5339\u914D\uFF0C\u800C\u662F\u6DF1\u5C42\u8054\u60F3\uFF09
+${memList}
+
+\u9009\u51FA\u6700\u76F8\u5173\u76841-3\u6761\uFF0C\u8F93\u51FA\u7F16\u53F7\u548C\u4E00\u53E5\u8BDD\u8BF4\u660E\u4E3A\u4EC0\u4E48\u76F8\u5173\u3002\u683C\u5F0F: "\u7F16\u53F7: \u539F\u56E0"\u3002\u90FD\u4E0D\u76F8\u5173\u5C31\u56DE\u7B54"\u65E0"`,
+    (output) => {
+      if (!output || output.includes("\u65E0") || output.length < 5) {
+        cachedAssociation = null;
+        return;
+      }
+      cachedAssociation = {
+        query: userMsg.slice(0, 50),
+        result: output.slice(0, 300),
+        ts: Date.now()
+      };
+      console.log(`[cc-soul][associative] found deep associations: ${output.slice(0, 80)}`);
+    }
+  );
+}
+__name(triggerAssociativeRecall, "triggerAssociativeRecall");
+function getAssociativeRecall() {
+  if (!cachedAssociation) return "";
+  if (Date.now() - cachedAssociation.ts > 3e5) {
+    cachedAssociation = null;
+    return "";
+  }
+  return `[\u6DF1\u5C42\u8054\u60F3] ${cachedAssociation.result}`;
+}
+__name(getAssociativeRecall, "getAssociativeRecall");
+let lastSessionSummaryTs = 0;
+const SESSION_SUMMARY_COOLDOWN = 18e5;
+function parseMemoryCommands(responseText) {
+  const commands = [];
+  const rememberPattern = /[（(](?:记下了|记住|记下|save)[：:]\s*(.+?)[）)]/g;
+  let match;
+  while ((match = rememberPattern.exec(responseText)) !== null) {
+    commands.push({ action: "remember", content: match[1].trim() });
+  }
+  const forgetPattern = /[（(](?:忘掉|忘记|forget|过时了)[：:]\s*(.+?)[）)]/g;
+  while ((match = forgetPattern.exec(responseText)) !== null) {
+    commands.push({ action: "forget", content: match[1].trim() });
+  }
+  const updatePattern = /[（(](?:更正记忆|更新记忆|update)[：:]\s*(.+?)\s*(?:→|->)+\s*(.+?)[）)]/g;
+  while ((match = updatePattern.exec(responseText)) !== null) {
+    commands.push({ action: "update", content: match[2].trim(), oldContent: match[1].trim() });
+  }
+  const searchPattern = /[（(](?:想查|查一下|search|回忆一下)[：:]\s*(.+?)[）)]/g;
+  while ((match = searchPattern.exec(responseText)) !== null) {
+    commands.push({ action: "search", content: match[1].trim() });
+  }
+  return commands;
+}
+__name(parseMemoryCommands, "parseMemoryCommands");
+let pendingSearchResults = [];
+function getPendingSearchResults() {
+  const results = [...pendingSearchResults];
+  pendingSearchResults = [];
+  return results;
+}
+__name(getPendingSearchResults, "getPendingSearchResults");
+function executeMemoryCommands(commands, userId, channelId) {
+  for (const cmd of commands) {
+    switch (cmd.action) {
+      case "remember":
+        addMemory(cmd.content, "fact", userId, "global", channelId);
+        console.log(`[cc-soul][active-memory] REMEMBER: ${cmd.content.slice(0, 60)}`);
+        break;
+      case "forget": {
+        const keyword = cmd.content.toLowerCase();
+        let forgotten = 0;
+        for (const mem of memoryState.memories) {
+          if (mem.content.toLowerCase().includes(keyword) && mem.scope !== "consolidated") {
+            mem.scope = "expired";
+            forgotten++;
+          }
+        }
+        if (forgotten > 0) {
+          saveMemories();
+          console.log(`[cc-soul][active-memory] FORGET: marked ${forgotten} memories as expired (keyword: ${cmd.content.slice(0, 30)})`);
+        }
+        break;
+      }
+      case "update": {
+        if (!cmd.oldContent) break;
+        const oldKw = cmd.oldContent.toLowerCase();
+        for (const mem of memoryState.memories) {
+          if (mem.content.toLowerCase().includes(oldKw) && mem.scope !== "expired") {
+            console.log(`[cc-soul][active-memory] UPDATE: "${mem.content.slice(0, 40)}" \u2192 "${cmd.content.slice(0, 40)}"`);
+            mem.content = cmd.content;
+            mem.ts = Date.now();
+            mem.tags = void 0;
+            break;
+          }
+        }
+        saveMemories();
+        break;
+      }
+      case "search": {
+        const results = recall(cmd.content, 5, userId, channelId);
+        if (results.length > 0) {
+          pendingSearchResults = results.map((m) => `- ${m.content}${m.emotion && m.emotion !== "neutral" ? ` (${m.emotion})` : ""}`);
+          console.log(`[cc-soul][active-memory] SEARCH "${cmd.content.slice(0, 30)}": found ${results.length} results (cached for next turn)`);
+        }
+        break;
+      }
+    }
+  }
+}
+__name(executeMemoryCommands, "executeMemoryCommands");
+let lastContradictionScan = 0;
+const CONTRADICTION_SCAN_COOLDOWN = 24 * 36e5;
+function scanForContradictions() {
+  const now = Date.now();
+  if (now - lastContradictionScan < CONTRADICTION_SCAN_COOLDOWN) return;
+  if (memoryState.memories.length < 20) return;
+  lastContradictionScan = now;
+  const conflictScopes = ["fact", "preference", "correction"];
+  const groups = /* @__PURE__ */ new Map();
+  for (const mem of memoryState.memories) {
+    if (!conflictScopes.includes(mem.scope)) continue;
+    if (mem.scope === "expired") continue;
+    if (!groups.has(mem.scope)) groups.set(mem.scope, []);
+    groups.get(mem.scope).push(mem);
+  }
+  for (const [scope, mems] of groups) {
+    if (mems.length < 5) continue;
+    const sorted = [...mems].sort((a, b) => b.ts - a.ts);
+    const recent = sorted.slice(0, 10);
+    const older = sorted.slice(10, 20);
+    if (older.length < 3) continue;
+    const recentList = recent.map((m, i) => `\u65B0${i + 1}. ${m.content.slice(0, 80)}`).join("\n");
+    const olderList = older.map((m, i) => `\u65E7${i + 1}. ${m.content.slice(0, 80)}`).join("\n");
+    spawnCLI(
+      `\u4EE5\u4E0B\u662F\u540C\u7C7B\u578B(${scope})\u7684\u65B0\u65E7\u8BB0\u5FC6\uFF0C\u68C0\u67E5\u662F\u5426\u6709\u77DB\u76FE\uFF08\u540C\u4E00\u4EF6\u4E8B\u8BF4\u6CD5\u4E0D\u540C\u3001\u524D\u540E\u4E0D\u4E00\u81F4\uFF09\u3002
+
+\u6700\u8FD1\u7684\u8BB0\u5FC6:
+${recentList}
+
+\u8F83\u65E9\u7684\u8BB0\u5FC6:
+${olderList}
+
+\u5982\u679C\u6709\u77DB\u76FE\uFF0C\u8F93\u51FA\u683C\u5F0F: "\u65E7N \u4E0E \u65B0M \u77DB\u76FE: \u539F\u56E0"\uFF08\u53EF\u591A\u6761\uFF09
+\u5982\u679C\u6CA1\u6709\u77DB\u76FE\uFF0C\u56DE\u7B54"\u65E0"`,
+      (output) => {
+        if (!output || output.includes("\u65E0")) return;
+        const lines = output.split("\n").filter((l) => l.includes("\u77DB\u76FE"));
+        let expired = 0;
+        for (const line of lines) {
+          const oldMatch = line.match(/旧(\d+)/);
+          if (oldMatch) {
+            const idx = parseInt(oldMatch[1]) - 1;
+            if (idx >= 0 && idx < older.length) {
+              const memIdx = memoryState.memories.findIndex((m) => m.content === older[idx].content && m.ts === older[idx].ts);
+              if (memIdx >= 0) {
+                memoryState.memories[memIdx].scope = "expired";
+                expired++;
+              }
+            }
+          }
+        }
+        if (expired > 0) {
+          saveMemories();
+          console.log(`[cc-soul][contradiction] expired ${expired} contradicted memories in scope "${scope}"`);
+        }
+      }
+    );
+  }
+}
+__name(scanForContradictions, "scanForContradictions");
+let lastPredictionTs = 0;
+let cachedPrediction = [];
+function predictiveRecall(userId, channelId) {
+  const now = Date.now();
+  const results = [...cachedPrediction];
+  cachedPrediction = [];
+  return results;
+}
+__name(predictiveRecall, "predictiveRecall");
+function generatePrediction(recentTopics, userId) {
+  if (recentTopics.length === 0) return;
+  if (Date.now() - lastPredictionTs < 6e4) return;
+  lastPredictionTs = Date.now();
+  const topicStr = recentTopics.slice(-3).join("\u3001");
+  const candidates = memoryState.memories.filter((m) => {
+    if (m.scope === "expired" || m.scope === "proactive") return false;
+    const content = m.content.toLowerCase();
+    return recentTopics.some((t) => content.includes(t.toLowerCase()));
+  }).sort((a, b) => b.ts - a.ts).slice(0, 5);
+  if (candidates.length > 0) {
+    cachedPrediction = candidates.map((m) => m.content);
+    console.log(`[cc-soul][predictive] pre-loaded ${candidates.length} memories for topics: ${topicStr}`);
+  }
+}
+__name(generatePrediction, "generatePrediction");
+function triggerSessionSummary(recentTurns) {
+  const now = Date.now();
+  if (now - lastSessionSummaryTs < SESSION_SUMMARY_COOLDOWN) return;
+  if (memoryState.chatHistory.length < 3) return;
+  lastSessionSummaryTs = now;
+  const turns = memoryState.chatHistory.slice(-(recentTurns || 10));
+  const conversation = turns.map((t) => `\u7528\u6237: ${t.user.slice(0, 200)}
+\u52A9\u624B: ${t.assistant.slice(0, 200)}`).join("\n\n");
+  spawnCLI(
+    `\u4EE5\u4E0B\u662F\u4E00\u6BB5\u5B8C\u6574\u5BF9\u8BDD\uFF0C\u8BF7\u5199\u4E00\u6761\u9AD8\u8D28\u91CF\u7684\u4F1A\u8BDD\u6458\u8981\uFF082-3\u53E5\u8BDD\uFF09\uFF0C\u5305\u542B\uFF1A
+1. \u8BA8\u8BBA\u4E86\u4EC0\u4E48\u4E3B\u9898
+2. \u5173\u952E\u7ED3\u8BBA\u6216\u51B3\u5B9A
+3. \u662F\u5426\u6709\u9057\u7559\u95EE\u9898
+\u4E0D\u8981\u8BF4"\u7528\u6237\u548C\u52A9\u624B\u8BA8\u8BBA\u4E86..."\uFF0C\u76F4\u63A5\u5199\u5185\u5BB9\u3002
+
+${conversation}`,
+    (output) => {
+      if (output && output.length > 20) {
+        addMemory(`[\u4F1A\u8BDD\u6458\u8981] ${output.slice(0, 300)}`, "consolidated", void 0, "global");
+        console.log(`[cc-soul][session-summary] ${output.slice(0, 80)}`);
+      }
+    }
+  );
+}
+__name(triggerSessionSummary, "triggerSessionSummary");
+let lastNetworkCleanup = 0;
+const NETWORK_CLEANUP_COOLDOWN = 24 * 36e5;
+function cleanupNetworkKnowledge() {
+  const now = Date.now();
+  if (now - lastNetworkCleanup < NETWORK_CLEANUP_COOLDOWN) return;
+  lastNetworkCleanup = now;
+  let expired = 0;
+  let downgraded = 0;
+  for (const mem of memoryState.memories) {
+    if (!mem.content.startsWith("[\u7F51\u7EDC\u77E5\u8BC6")) continue;
+    if (mem.scope === "expired") continue;
+    const ageDays = (now - mem.ts) / 864e5;
+    if (ageDays > 90 && (!mem.tags || mem.tags.length === 0)) {
+      mem.scope = "expired";
+      expired++;
+      continue;
+    }
+    if (mem.content.includes("\u4F4E\u53EF\u4FE1") && ageDays > 30) {
+      mem.scope = "expired";
+      expired++;
+      continue;
+    }
+    if (mem.content.includes("\u5F85\u9A8C\u8BC1") && ageDays > 60) {
+      mem.scope = "expired";
+      downgraded++;
+      continue;
+    }
+  }
+  if (expired > 0 || downgraded > 0) {
+    saveMemories();
+    console.log(`[cc-soul][network-cleanup] expired ${expired}, downgraded ${downgraded} network memories`);
+  }
+}
+__name(cleanupNetworkKnowledge, "cleanupNetworkKnowledge");
+function resolveNetworkConflicts() {
+  const now = Date.now();
+  const localFacts = memoryState.memories.filter(
+    (m) => !m.content.startsWith("[\u7F51\u7EDC\u77E5\u8BC6") && (m.scope === "fact" || m.scope === "consolidated") && m.scope !== "expired"
+  );
+  const networkFacts = memoryState.memories.filter(
+    (m) => m.content.startsWith("[\u7F51\u7EDC\u77E5\u8BC6") && m.scope !== "expired"
+  );
+  if (localFacts.length === 0 || networkFacts.length === 0) return;
+  let resolved = 0;
+  for (const net of networkFacts) {
+    const netWords = new Set(
+      (net.content.match(/[\u4e00-\u9fff]{2,}|[a-z]{3,}/gi) || []).map((w) => w.toLowerCase())
+    );
+    for (const local of localFacts) {
+      const localWords = (local.content.match(/[\u4e00-\u9fff]{2,}|[a-z]{3,}/gi) || []).map((w) => w.toLowerCase());
+      const overlap = localWords.filter((w) => netWords.has(w)).length;
+      if (overlap >= 3 && local.content !== net.content.replace(/^\[网络知识[|｜][^\]]*\]\s*/, "")) {
+        if (local.ts > net.ts) {
+          net.scope = "expired";
+          resolved++;
+          break;
+        }
+      }
+    }
+  }
+  if (resolved > 0) {
+    saveMemories();
+    console.log(`[cc-soul][network-conflicts] resolved ${resolved} network vs local conflicts (local wins)`);
+  }
+}
+__name(resolveNetworkConflicts, "resolveNetworkConflicts");
+export {
+  addMemory,
+  addMemoryWithEmotion,
+  addToHistory,
+  batchTagUntaggedMemories,
+  buildHistoryContext,
+  cleanupNetworkKnowledge,
+  consolidateFragments,
+  consolidateMemories,
+  executeMemoryCommands,
+  generatePrediction,
+  getAssociativeRecall,
+  getPendingSearchResults,
+  invalidateIDF,
+  loadMemories,
+  memoryState,
+  parseMemoryCommands,
+  predictiveRecall,
+  recall,
+  recallFeedbackLoop,
+  resolveNetworkConflicts,
+  saveMemories,
+  scanForContradictions,
+  triggerAssociativeRecall,
+  triggerSessionSummary
+};

package/cc-soul/metacognition.js

@@ -0,0 +1 @@
+function checkAugmentConsistency(t){if(t.length<2)return"";const n=[],s=t.map(t=>t.content.toLowerCase()),e=[["简洁","详细"],["简短","展开"],["不擅长","擅长"],["不确定","确定"],["谨慎","果断"],["先共情","直接给方案"]];for(const[t,o]of e){const e=s.some(n=>n.includes(t)),u=s.some(t=>t.includes(o));e&&u&&n.push(`"${t}" vs "${o}"`)}const o=s.some(t=>t.includes("不擅长")||t.includes("说不确定")),u=s.some(t=>t.includes("擅长领域")||t.includes("高信心"));o&&u&&n.push('计划说"不擅长"但知识边界说"高信心"——以最新计划为准');const f=s.filter(t=>t.includes("[相关记忆]")||t.includes("[确定性知识]")),c=s.filter(t=>t.includes("[注意规则]")||t.includes("[行动计划"));if(f.length>0&&c.length>0)for(const t of f)for(const s of c){const e=new Set(t.match(/[\u4e00-\u9fff]{2,}/g)||[]),o=new Set(s.match(/[\u4e00-\u9fff]{2,}/g)||[]);if([...e].filter(t=>o.has(t)).length>=3){n.push("记忆和规则可能涉及同一话题——以规则/计划为准");break}}return 0===n.length?"":`[元认知警告] 注入上下文有潜在冲突: ${n.join("；")}。请以最新信息和规则为准。`}let lastAugmentSnapshot=[];function snapshotAugments(t){lastAugmentSnapshot=[...t]}function getLastAugmentSnapshot(){return lastAugmentSnapshot}export{checkAugmentConsistency,getLastAugmentSnapshot,snapshotAugments};