openclaw-amem 2.1.2 → 2.1.4

package/dist/index.js

@@ -257,15 +257,15 @@ async function recordCollectionModel(collection, model) {
   } catch {
   }
 }
-async function qdrant(method, path6, body) {
-  const res = await fetch(`${QDRANT_URL}${path6}`, {
+async function qdrant(method, path7, body) {
+  const res = await fetch(`${QDRANT_URL}${path7}`, {
     method,
     headers: { "Content-Type": "application/json" },
     body: body ? JSON.stringify(body) : void 0
   });
   const data = await res.json();
   if (!res.ok || data.status && data.status !== "ok" && data.status !== "acknowledged") {
-    throw new Error(`Qdrant ${method} ${path6} failed: ${data.error || JSON.stringify(data)}`);
+    throw new Error(`Qdrant ${method} ${path7} failed: ${data.error || JSON.stringify(data)}`);
   }
   return data.result;
 }
@@ -318,12 +318,12 @@ async function ensureCollection(collectionName) {
         throw new EmbeddingDimensionMismatchError(col, collectionDim, modelDim, getEmbeddingModel());
       }
     }
-    const current = getEmbeddingModel();
-    if (typeof recorded === "string" && recorded !== current) {
-      throw new EmbeddingModelMismatchError(col, recorded, current);
+    const current2 = getEmbeddingModel();
+    if (typeof recorded === "string" && recorded !== current2) {
+      throw new EmbeddingModelMismatchError(col, recorded, current2);
     }
     if (recorded === void 0 && !inferLegacy) {
-      await recordCollectionModel(col, current);
+      await recordCollectionModel(col, current2);
     }
     markReady();
     return;
@@ -1131,6 +1131,45 @@ ${numberedNotes}
   }
 });
 
+// ../amem-core/src/deadline.ts
+function hasTimeFor(deadline) {
+  return deadline === void 0 || deadline - Date.now() >= MIN_CALL_MS;
+}
+var MIN_CALL_MS;
+var init_deadline = __esm({
+  "../amem-core/src/deadline.ts"() {
+    "use strict";
+    MIN_CALL_MS = 3e3;
+  }
+});
+
+// ../amem-core/src/background.ts
+function runInBackground(busy, job) {
+  return current.run(busy, job);
+}
+function stopIfForegroundBusy() {
+  if (current.getStore()?.()) throw new BackgroundPreempted();
+}
+async function pauseForForeground() {
+  if (!current.getStore()) return;
+  await new Promise((resolve2) => setImmediate(resolve2));
+  stopIfForegroundBusy();
+}
+var import_node_async_hooks, current, BackgroundPreempted;
+var init_background = __esm({
+  "../amem-core/src/background.ts"() {
+    "use strict";
+    import_node_async_hooks = require("async_hooks");
+    current = new import_node_async_hooks.AsyncLocalStorage();
+    BackgroundPreempted = class extends Error {
+      constructor() {
+        super("stopped for a run in the foreground");
+        this.name = "BackgroundPreempted";
+      }
+    };
+  }
+});
+
 // ../amem-core/src/llm.ts
 function configureLlm(cfg) {
   _override = { ...cfg };
@@ -1166,6 +1205,12 @@ function resolveCrudRole() {
   }
   return "fast";
 }
+function resolveThinking() {
+  const raw = (process.env.AMEM_LLM_THINKING || _override.thinking || "off").trim().toLowerCase();
+  if (raw === "auto") return "auto";
+  if (raw !== "off") warnOnce(`thinking:${raw}`, `[amem] unknown AMEM_LLM_THINKING "${raw}"; using off`);
+  return "off";
+}
 function resolveTimeoutMs() {
   const envVal = Number(process.env.AMEM_LLM_TIMEOUT);
   if (Number.isFinite(envVal) && envVal > 0) return envVal;
@@ -1202,39 +1247,70 @@ function openai(baseURL) {
   }
   return client;
 }
-async function llmCall(prompt, maxTokens = 500, role = "fast") {
+async function llmCall(prompt, maxTokens = 500, role = "fast", opts = {}) {
+  stopIfForegroundBusy();
+  if (!hasTimeFor(opts.deadline)) {
+    warn(`[amem] skipped an LLM call: less than ${MIN_CALL_MS} ms left before the deadline`);
+    return null;
+  }
+  const request = () => opts.deadline === void 0 ? void 0 : { timeout: Math.min(resolveTimeoutMs(), opts.deadline - Date.now()), maxRetries: 0 };
   const provider = resolveProvider(role);
   const model = resolveModel(role);
   const baseURL = resolveBaseURL(role);
-  const isThinking = model.includes("gemini") || model.includes("pro-agent");
-  const effectiveMaxTokens = isThinking ? Math.max(maxTokens * 8, 4e3) : maxTokens;
+  const pair = `${baseURL ?? ""}|${model}`;
+  const thinkingOff = provider !== "openai" && role === "fast" && resolveThinking() === "off" && !_thinkingStaysOn.has(pair);
+  const mayThink = model.includes("gemini") || model.includes("pro-agent") || (provider === "openai" ? isOpenAIReasoning(model) : !thinkingOff);
+  const effectiveMaxTokens = mayThink ? roomToThink(maxTokens) : maxTokens;
+  let text = null;
   try {
-    const text = provider === "openai" ? await openaiCall(prompt, model, effectiveMaxTokens, baseURL) : await anthropicCall(prompt, model, effectiveMaxTokens, baseURL);
+    if (provider === "openai") {
+      text = await openaiCall(prompt, model, effectiveMaxTokens, baseURL, request());
+    } else if (!thinkingOff) {
+      text = await anthropicCall(prompt, model, effectiveMaxTokens, baseURL, request());
+    } else {
+      try {
+        text = await anthropicCall(prompt, model, effectiveMaxTokens, baseURL, request(), { type: "disabled" });
+      } catch (e) {
+        if (e.status !== 400 || !hasTimeFor(opts.deadline)) throw e;
+        text = await anthropicCall(prompt, model, roomToThink(maxTokens), baseURL, request());
+        _thinkingStaysOn.add(pair);
+        warnOnce(`thinking-on:${pair}`, `[amem] ${model} refused thinking disabled; its fast calls keep thinking`);
+      }
+    }
     if (text === null) warn(`[amem] ${provider} answered with no text (model ${model})`);
-    return text;
   } catch (e) {
     warn(`[amem] LLM call failed: ${e.message}`);
-    return null;
   }
+  stopIfForegroundBusy();
+  return text;
 }
-async function anthropicCall(prompt, model, maxTokens, baseURL) {
-  const resp = await anthropic(baseURL).messages.create({
-    model,
-    max_tokens: maxTokens,
-    messages: [{ role: "user", content: prompt }]
-  });
+async function anthropicCall(prompt, model, maxTokens, baseURL, request, thinking) {
+  const resp = await anthropic(baseURL).messages.create(
+    {
+      model,
+      max_tokens: maxTokens,
+      messages: [{ role: "user", content: prompt }],
+      ...thinking && { thinking }
+    },
+    request
+  );
   for (const block of resp.content) {
     if (block.type === "text") return block.text.trim();
   }
   return null;
 }
-async function openaiCall(prompt, model, maxTokens, baseURL) {
-  const isReasoning = /^o\d/.test(model) || model.startsWith("gpt-5");
-  const resp = await openai(baseURL).chat.completions.create({
-    model,
-    ...isReasoning ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
-    messages: [{ role: "user", content: prompt }]
-  });
+function isOpenAIReasoning(model) {
+  return /^o\d/.test(model) || model.startsWith("gpt-5");
+}
+async function openaiCall(prompt, model, maxTokens, baseURL, request) {
+  const resp = await openai(baseURL).chat.completions.create(
+    {
+      model,
+      ...isOpenAIReasoning(model) ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
+      messages: [{ role: "user", content: prompt }]
+    },
+    request
+  );
   return resp.choices[0]?.message?.content?.trim() ?? null;
 }
 function stripReasoning(raw) {
@@ -1266,7 +1342,7 @@ function parseJsonLoose(raw) {
     throw e;
   }
 }
-async function llmConstructNote(content) {
+async function llmConstructNote(content, opts = {}) {
   const prompt = `Analyze the following text and respond with valid JSON only (no markdown fences, no explanation, no comments). All string values must use standard double quotes and be properly escaped:
 {
   "keywords": ["keyword1", "keyword2"],
@@ -1301,7 +1377,7 @@ confidence guide (Story 27):
 - low: LLM is uncertain \u2014 vague, fragmentary, or mixed content
 
 Text: ${content}`;
-  const raw = await llmCall(prompt, 400);
+  const raw = await llmCall(prompt, 400, "fast", opts);
   if (!raw) {
     warn("[amem] note construction got nothing back; storing with no keywords, tags or context");
     return {
@@ -1344,21 +1420,21 @@ Text: ${content}`;
     };
   }
 }
-async function llmShouldLink(noteContent, candidateContent) {
+async function llmShouldLink(noteContent, candidateContent, opts = {}) {
   const prompt = `Do these two memory notes have a meaningful relationship that would be useful to link?
 Reply with only "yes" or "no".
 
 Note A: ${noteContent}
 Note B: ${candidateContent}`;
-  const raw = await llmCall(prompt, 10);
+  const raw = await llmCall(prompt, 10, "fast", opts);
   if (!raw) return false;
   return raw.toLowerCase().startsWith("yes");
 }
-async function llmCrudDecision(userText, assistantText, existingMemories) {
+async function llmCrudDecision(userText, assistantText, existingMemories, opts = {}) {
   const memoryList = existingMemories.length > 0 ? existingMemories.map((m) => `[${m.idx}] ${m.content}`).join("\n") : "(none)";
   const prompt = t.crudDecision(userText.slice(0, 500), assistantText.slice(0, 500), memoryList);
   try {
-    const raw = await llmCall(prompt, 400, resolveCrudRole());
+    const raw = await llmCall(prompt, 400, resolveCrudRole(), opts);
     if (!raw) return [];
     const match = stripReasoning(raw).match(/\[.*\]/s);
     if (!match) {
@@ -1430,7 +1506,7 @@ async function llmEvolutionJudge(oldContent, newContent) {
     return { type: "NEW" };
   }
 }
-async function llmEvolveNote(content, linkedNotes) {
+async function llmEvolveNote(content, linkedNotes, opts = {}) {
   const linkedStr = linkedNotes.map((n) => `- ID: ${n.id}
   Content: ${n.content}`).join("\n");
   const prompt = `A memory note has gained new connections. Update its context, tags, and decide whether to strengthen connections with specific neighbors.
@@ -1453,7 +1529,7 @@ Original note content: ${content}
 
 Newly linked notes (neighbors):
 ${linkedStr}`;
-  const raw = await llmCall(prompt, 500);
+  const raw = await llmCall(prompt, 500, "fast", opts);
   if (!raw) return { tags: null, context: null, shouldStrengthen: false, suggestedConnections: [], tagsToUpdate: [] };
   try {
     const data = parseJsonLoose(raw);
@@ -1472,19 +1548,19 @@ ${linkedStr}`;
 async function llmConflictScan(contents) {
   if (contents.length < 2) return [];
   const numbered = contents.map((c, i) => `[${i}] ${c}`).join("\n");
+  const raw = await llmCall(t.conflictScan(numbered), 600, "strong");
+  if (!raw) return null;
   try {
-    const raw = await llmCall(t.conflictScan(numbered), 600, "strong");
-    if (!raw) return [];
     const cleaned = stripReasoning(raw);
     const match = cleaned.match(/\[[\s\S]*\]/);
     if (!match) {
-      warn("[amem] llmConflictScan found no array in the response; this sweep reports no pairs");
-      return [];
+      warn("[amem] llmConflictScan found no array in the response; the batch is read again next run");
+      return null;
     }
     const parsed = JSON.parse(match[0]);
     if (!Array.isArray(parsed)) {
-      warn("[amem] llmConflictScan parsed a non-array; this sweep reports no pairs");
-      return [];
+      warn("[amem] llmConflictScan parsed a non-array; the batch is read again next run");
+      return null;
     }
     const pairs = [];
     const seen = /* @__PURE__ */ new Set();
@@ -1507,13 +1583,17 @@ async function llmConflictScan(contents) {
         supersededIndex
       });
     }
+    if (parsed.length > 0 && pairs.length === 0) {
+      warn("[amem] llmConflictScan got no valid pair in the response; the batch is read again next run");
+      return null;
+    }
     return pairs;
   } catch (e) {
     warn(`[amem] llmConflictScan failed: ${e.message}`);
-    return [];
+    return null;
   }
 }
-var import_sdk, import_openai, _override, _warned, DEFAULT_TIMEOUT_MS, _anthropicClients, _openaiClients, VALID_CONFIDENCE, VALID_CATEGORIES, VALID_EVOLUTION_TYPES;
+var import_sdk, import_openai, _override, _warned, _thinkingStaysOn, roomToThink, DEFAULT_TIMEOUT_MS, _anthropicClients, _openaiClients, VALID_CONFIDENCE, VALID_CATEGORIES, VALID_EVOLUTION_TYPES;
 var init_llm = __esm({
   "../amem-core/src/llm.ts"() {
     "use strict";
@@ -1521,8 +1601,12 @@ var init_llm = __esm({
     import_openai = __toESM(require("openai"), 1);
     init_prompts();
     init_config();
+    init_deadline();
+    init_background();
     _override = {};
     _warned = /* @__PURE__ */ new Set();
+    _thinkingStaysOn = /* @__PURE__ */ new Set();
+    roomToThink = (maxTokens) => Math.max(maxTokens * 8, 4e3);
     DEFAULT_TIMEOUT_MS = 3e4;
     _anthropicClients = /* @__PURE__ */ new Map();
     _openaiClients = /* @__PURE__ */ new Map();
@@ -1659,7 +1743,8 @@ async function addMemory(content, agentId = "main", opts) {
     return existingByHash.id;
   }
   console.log("[add] Constructing note...");
-  const { keywords, tags, context, category, note_type, topics } = await llmConstructNote(content);
+  const deadline = opts?.deadline;
+  const { keywords, tags, context, category, note_type, topics } = await llmConstructNote(content, { deadline });
   console.log(`  keywords: ${keywords.join(", ")}`);
   console.log(`  tags: ${tags.join(", ")}`);
   console.log(`  context: ${context}`);
@@ -1732,8 +1817,9 @@ async function addMemory(content, agentId = "main", opts) {
       for (const { note: cand, score } of candidates) {
         if (cand.id === note.id) continue;
         if (score < 0.3) continue;
+        if (!hasTimeFor(deadline)) break;
         console.log(`  candidate ${cand.id.slice(0, 8)}... sim=${score.toFixed(3)}, asking LLM...`);
-        const shouldLink = await llmShouldLink(content, cand.content);
+        const shouldLink = await llmShouldLink(content, cand.content, { deadline });
         if (shouldLink) {
           linkedIds.push(cand.id);
           linkedContents.push(cand.content);
@@ -1757,6 +1843,7 @@ async function addMemory(content, agentId = "main", opts) {
         if (shouldRunEvolution()) {
           console.log(`  [evo] threshold reached, running evolution for ${Math.min(linkedIds.length, 3)} linked notes`);
           for (const lid of linkedIds.slice(0, 3)) {
+            if (!hasTimeFor(deadline)) break;
             const linked = await ctx.getNote(lid, agentId);
             if (!linked) continue;
             if (!canWrite(linked, agentId)) {
@@ -1778,7 +1865,7 @@ async function addMemory(content, agentId = "main", opts) {
               shouldStrengthen,
               suggestedConnections,
               tagsToUpdate
-            } = await llmEvolveNote(linked.content, linkedNotes);
+            } = await llmEvolveNote(linked.content, linkedNotes, { deadline });
             let evolved = false;
             if (newTags !== null || newContext !== null) {
               if (newTags !== null) linked.tags = newTags;
@@ -1999,10 +2086,9 @@ async function listMemories(agentId = "main", storageCtx) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function mergeSimilarNotes(agentId, storageCtx) {
+async function mergeSimilarNotes(agentId, storageCtx, date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) {
   const ctx = storageCtx ?? defaultCtx();
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const allNotes = await ctx.getNotesByDatePrefix(today, agentId);
+  const allNotes = await ctx.getNotesByDatePrefix(date, agentId);
   const notes = allNotes.filter((n) => n.agent_id !== "shared");
   const pendingNotes = notes.filter((n) => n.pending_merge === true);
   let evolvedCount = 0;
@@ -2020,6 +2106,7 @@ async function mergeSimilarNotes(agentId, storageCtx) {
       }
     }
     if (!bestNeighbor) {
+      stopIfForegroundBusy();
       await ctx.patchNotePayload(pendingNote.id, { pending_merge: false });
       continue;
     }
@@ -2140,6 +2227,7 @@ async function consolidateMemories(agentId, logger, storageCtx) {
   for (const [category, groupNotes] of groups.entries()) {
     log.info(`[Consolidation] Category "${category}" has ${groupNotes.length} notes.`);
     for (let i = 0; i < groupNotes.length; i++) {
+      await pauseForForeground();
       for (let j = i + 1; j < groupNotes.length; j++) {
         const noteA = groupNotes[i];
         const noteB = groupNotes[j];
@@ -2249,6 +2337,7 @@ async function conflictSweep(agentId, opts) {
   let retired = 0;
   let batchesScanned = 0;
   let batchesSkipped = 0;
+  let batchesFailed = 0;
   for (const [category, groupNotes] of groups.entries()) {
     groupNotes.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
     for (let start = 0; start < groupNotes.length; start += CONFLICT_BATCH_SIZE) {
@@ -2260,6 +2349,10 @@ async function conflictSweep(agentId, opts) {
       }
       batchesScanned++;
       const pairs = await llmConflictScan(batch.map((n) => n.content));
+      if (pairs === null) {
+        batchesFailed++;
+        continue;
+      }
       for (const { a, b, reason, supersededIndex } of pairs) {
         const noteA = batch[a];
         const noteB = batch[b];
@@ -2298,9 +2391,9 @@ async function conflictSweep(agentId, opts) {
     }
   }
   log(
-    `[conflict] ${batchesScanned} batch(es) scanned, ${batchesSkipped} already up to date; ${pairsFound} pair(s) found, ${retired} retired`
+    `[conflict] ${batchesScanned} batch(es) scanned, ${batchesSkipped} already up to date` + (batchesFailed > 0 ? `, ${batchesFailed} with no answer (read again next run)` : "") + `; ${pairsFound} pair(s) found, ${retired} retired`
   );
-  return { scanned: notes.length, pairsFound, retired, batchesScanned, batchesSkipped };
+  return { scanned: notes.length, pairsFound, retired, batchesScanned, batchesSkipped, batchesFailed };
 }
 var import_uuid, import_crypto, fs2, path3, import_jieba, logSafe, _jieba, EPHEMERAL_SIGNALS, CONFLICT_BATCH_SIZE;
 var init_memory = __esm({
@@ -2315,6 +2408,8 @@ var init_memory = __esm({
     init_auth();
     init_llm();
     init_evo_counter();
+    init_deadline();
+    init_background();
     init_config();
     import_jieba = require("@node-rs/jieba");
     logSafe = (id) => id.replace(/[\r\n]/g, "");
@@ -2687,6 +2782,7 @@ var init_crud_guard = __esm({
 // ../amem-core/src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BackgroundPreempted: () => BackgroundPreempted,
   DEFAULT_CRUD_UPDATE_MIN_SIM: () => DEFAULT_CRUD_UPDATE_MIN_SIM,
   DEFAULT_EMBEDDING_MODEL: () => DEFAULT_EMBEDDING_MODEL,
   EmbeddingDimensionMismatchError: () => EmbeddingDimensionMismatchError,
@@ -2715,6 +2811,7 @@ __export(src_exports, {
   getEmbeddingModel: () => getEmbeddingModel,
   getEmbeddingPooling: () => getEmbeddingPooling,
   getNote: () => getNote,
+  hasTimeFor: () => hasTimeFor,
   invalidateNote: () => invalidateNote,
   isModelLoaded: () => isModelLoaded,
   isPlausibleUpdateTarget: () => isPlausibleUpdateTarget,
@@ -2727,6 +2824,7 @@ __export(src_exports, {
   patchNotePayload: () => patchNotePayload,
   pingQdrant: () => pingQdrant,
   resolveCrudUpdateMinSim: () => resolveCrudUpdateMinSim,
+  runInBackground: () => runInBackground,
   scanLowQuality: () => scanLowQuality,
   searchMemory: () => searchMemory,
   switchToMigrated: () => switchToMigrated,
@@ -2747,6 +2845,8 @@ var init_src = __esm({
     init_memory();
     init_crud_guard();
     init_llm();
+    init_deadline();
+    init_background();
   }
 });
 
@@ -2773,7 +2873,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var os2 = __toESM(require("os"));
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 var import_plugin_entry = require("openclaw/plugin-sdk/plugin-entry");
 init_src();
 var import_crypto2 = require("crypto");
@@ -2786,6 +2886,237 @@ function isConvAccessBlocked(config, pluginId) {
   return entry !== void 0 && entry.hooks?.allowConversationAccess !== true;
 }
 
+// src/nightly.ts
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var SLOT = /* @__PURE__ */ Symbol.for("openclaw-amem.nightly-timer");
+function msUntil(hour, minute, now = /* @__PURE__ */ new Date()) {
+  const target = new Date(now);
+  target.setHours(hour, minute, 0, 0);
+  if (target.getTime() <= now.getTime()) target.setDate(target.getDate() + 1);
+  return target.getTime() - now.getTime();
+}
+function scheduleNightly(job, onError) {
+  const holder = globalThis;
+  if (holder[SLOT]) clearTimeout(holder[SLOT]);
+  const timer = setTimeout(
+    async () => {
+      try {
+        await job();
+      } catch (err) {
+        onError(err);
+      } finally {
+        if (holder[SLOT] === timer) scheduleNightly(job, onError);
+      }
+    },
+    msUntil(2, 30)
+  );
+  timer.unref();
+  holder[SLOT] = timer;
+}
+function cancelNightly() {
+  const holder = globalThis;
+  if (holder[SLOT]) clearTimeout(holder[SLOT]);
+  delete holder[SLOT];
+}
+function readFile(file) {
+  try {
+    const data = JSON.parse(fs4.readFileSync(file, "utf-8"));
+    const agents = {};
+    for (const [id, entry] of Object.entries(data.agents ?? {})) {
+      if (typeof entry?.from === "string" && typeof entry.wrote === "string") {
+        agents[id] = { from: entry.from, wrote: entry.wrote };
+      }
+    }
+    return { agents };
+  } catch {
+    return { agents: {} };
+  }
+}
+function writeFile(file, owed) {
+  fs4.mkdirSync(path5.dirname(file), { recursive: true });
+  fs4.writeFileSync(file, JSON.stringify(owed));
+}
+function markOwed(file, rawAgentId, since, now = /* @__PURE__ */ new Date()) {
+  const owed = readFile(file);
+  owed.agents[rawAgentId] = {
+    from: owed.agents[rawAgentId]?.from ?? since.toISOString(),
+    wrote: now.toISOString()
+  };
+  writeFile(file, owed);
+}
+function readOwed(file) {
+  return new Map(Object.entries(readFile(file).agents).map(([id, entry]) => [id, new Date(entry.from)]));
+}
+function settleAgent(file, rawAgentId, startedAt) {
+  const owed = readFile(file);
+  const entry = owed.agents[rawAgentId];
+  if (!entry) return;
+  if (Date.parse(entry.wrote) < startedAt.getTime()) delete owed.agents[rawAgentId];
+  else entry.from = startedAt.toISOString();
+  writeFile(file, owed);
+}
+function utcDatesSince(since, now, maxDays = 7) {
+  const DAY = 864e5;
+  const utcMidnight = (t2) => t2 - t2 % DAY;
+  const last = utcMidnight(now.getTime());
+  const earliest = last - (maxDays - 1) * DAY;
+  const first = Math.max(utcMidnight(since ? since.getTime() : now.getTime() - DAY), earliest);
+  const days = [];
+  for (let t2 = first; t2 <= last; t2 += DAY) days.push(new Date(t2).toISOString().slice(0, 10));
+  return days;
+}
+var FOREGROUND = /* @__PURE__ */ Symbol.for("openclaw-amem.foreground");
+var STALE_MS = 30 * 6e4;
+var QUIET_MS = 6e4;
+var NIGHTLY_WAIT_CAP_MS = 60 * 6e4;
+var MAX_ATTEMPTS = 3;
+function foreground() {
+  const holder = globalThis;
+  return holder[FOREGROUND] ??= { inFlight: /* @__PURE__ */ new Map(), lastActivity: 0, events: 0 };
+}
+function touch(fg, now) {
+  fg.lastActivity = now;
+  fg.events++;
+}
+var compactionKey = (session) => `compaction:${session}`;
+function noteAgentEvent(evt, now = Date.now()) {
+  const fg = foreground();
+  touch(fg, now);
+  if (!evt.runId) return;
+  const phase = evt.stream === "lifecycle" ? evt.data?.phase : void 0;
+  if (phase === "start") {
+    fg.inFlight.set(evt.runId, now);
+  } else if (phase === "end" || phase === "error") {
+    fg.inFlight.delete(evt.runId);
+    for (const session of [evt.sessionKey, evt.sessionId]) if (session) fg.inFlight.delete(compactionKey(session));
+  } else if (fg.inFlight.has(evt.runId)) {
+    fg.inFlight.set(evt.runId, now);
+  }
+}
+function watchAgentEvents(subscribe) {
+  const fg = foreground();
+  fg.unsubscribe?.();
+  fg.unsubscribe = subscribe((evt) => noteAgentEvent(evt));
+}
+function unwatchAgentEvents() {
+  const fg = foreground();
+  fg.unsubscribe?.();
+  delete fg.unsubscribe;
+}
+function foregroundWorkStarted(now = Date.now()) {
+  const fg = foreground();
+  const token = /* @__PURE__ */ Symbol("agent_end");
+  fg.inFlight.set(token, now);
+  touch(fg, now);
+  return () => {
+    fg.inFlight.delete(token);
+    touch(fg, Date.now());
+  };
+}
+function compactionStarted(ctx, now = Date.now()) {
+  const fg = foreground();
+  touch(fg, now);
+  const session = ctx?.sessionKey ?? ctx?.sessionId;
+  if (session) fg.inFlight.set(compactionKey(session), now);
+}
+function compactionEnded(ctx, now = Date.now()) {
+  const fg = foreground();
+  touch(fg, now);
+  const session = ctx?.sessionKey ?? ctx?.sessionId;
+  if (session) fg.inFlight.delete(compactionKey(session));
+}
+function noteMessageReceived(event, now = Date.now()) {
+  const update = event?.providerUpdate;
+  if (update?.editedTimestamp !== void 0 || update?.kind?.startsWith("edited_")) return;
+  touch(foreground(), now);
+}
+function foregroundBusy(now = Date.now()) {
+  const { inFlight } = foreground();
+  for (const [key, seen] of inFlight) if (now - seen > STALE_MS) inFlight.delete(key);
+  return inFlight.size > 0;
+}
+function busySinceNow() {
+  const fg = foreground();
+  const seen = fg.events;
+  return () => foregroundBusy() || fg.events !== seen;
+}
+function makeIdleWaiter(pollMs = 15e3, capMs = NIGHTLY_WAIT_CAP_MS) {
+  let waited = 0;
+  return {
+    async untilIdle() {
+      for (; ; ) {
+        const now = Date.now();
+        if (!foregroundBusy(now) && now - foreground().lastActivity >= QUIET_MS) return true;
+        if (waited >= capMs) return false;
+        await new Promise((resolve2) => setTimeout(resolve2, pollMs).unref());
+        waited += Date.now() - now;
+      }
+    },
+    waitedMs: () => waited
+  };
+}
+async function runStep(idle, attempt, preempted, onPreempted) {
+  for (let tries = 1; ; tries++) {
+    if (!await idle.untilIdle()) return "out of waiting";
+    try {
+      await attempt();
+      return "done";
+    } catch (err) {
+      if (!preempted(err)) throw err;
+      if (tries >= MAX_ATTEMPTS) return "stopped too often";
+      onPreempted();
+    }
+  }
+}
+async function runNightly(work, startedAt = /* @__PURE__ */ new Date()) {
+  const { logger } = work;
+  const idle = work.idle ?? makeIdleWaiter();
+  let stopped = false;
+  const step = async (name, run) => {
+    if (stopped) return false;
+    const result = await runStep(
+      idle,
+      () => work.inBackground(run),
+      work.preempted,
+      () => logger.info(`openclaw-amem: nightly ${name} stopped for a running task; it runs again when the gateway is idle`)
+    );
+    if (result === "done") return true;
+    stopped = true;
+    logger.warn(
+      result === "out of waiting" ? `openclaw-amem: nightly job waited ${Math.round(idle.waitedMs() / 6e4)} min for running tasks; the rest runs tomorrow` : `openclaw-amem: nightly ${name} was stopped ${MAX_ATTEMPTS} times by running tasks; the rest runs tomorrow`
+    );
+    return false;
+  };
+  try {
+    const owed = readOwed(work.owedFile);
+    merging: for (const agent of /* @__PURE__ */ new Set([work.defaultAgent, ...owed.keys()])) {
+      let failed = false;
+      for (const day of utcDatesSince(owed.get(agent), startedAt)) {
+        try {
+          if (!await step(`merge (${agent}, ${day})`, () => work.mergeDay(agent, day))) break merging;
+        } catch (err) {
+          failed = true;
+          logger.warn(`openclaw-amem: merge failed (${agent}, ${day}) \u2014 ${err.message}`);
+        }
+      }
+      if (!failed) settleAgent(work.owedFile, agent, startedAt);
+    }
+  } catch (err) {
+    logger.warn(`openclaw-amem: nightly merge failed \u2014 ${err.message}`);
+  }
+  for (const { name, run } of work.after) {
+    try {
+      await step(name, run);
+    } catch (err) {
+      logger.warn(`openclaw-amem: nightly ${name} failed \u2014 ${err.message}`);
+    }
+  }
+  if (idle.waitedMs() > 0) {
+    logger.info(`openclaw-amem: nightly job waited ${Math.round(idle.waitedMs() / 1e3)} s for running tasks`);
+  }
+}
+
 // src/scope.ts
 function parseAgentIdFromSessionKey(sessionKey) {
   if (!sessionKey) return void 0;
@@ -2811,6 +3142,8 @@ function buildScope(rawAgentId, pluginConfig, createStorageContext2) {
 // src/index.ts
 init_src();
 var _config = {};
+var HOOK_BUDGET_MS = 3e4;
+var HOOK_MARGIN_MS = 2e3;
 function register(api) {
   const logger = api.logger;
   _config = api.pluginConfig || {};
@@ -2819,16 +3152,17 @@ function register(api) {
   const convBlocked = isConvAccessBlocked(api.config, pluginId);
   if (convBlocked) logger.warn(BLOCKED_WARNING_LOG);
   configure({
-    dataDir: path5.join(os2.homedir(), ".openclaw"),
+    dataDir: path6.join(os2.homedir(), ".openclaw"),
     warn: (msg) => logger.warn(msg)
   });
   const hasStrong = !!(pluginConfig.llmStrongProvider || pluginConfig.llmStrongModel || pluginConfig.llmStrongBaseURL);
-  if (pluginConfig.llmProvider || pluginConfig.llmModel || pluginConfig.llmBaseURL || pluginConfig.llmCrudRole || hasStrong) {
+  if (pluginConfig.llmProvider || pluginConfig.llmModel || pluginConfig.llmBaseURL || pluginConfig.llmCrudRole || pluginConfig.llmThinking || hasStrong) {
     configureLlm({
       provider: pluginConfig.llmProvider,
       model: pluginConfig.llmModel,
       baseURL: pluginConfig.llmBaseURL,
       crudRole: pluginConfig.llmCrudRole,
+      thinking: pluginConfig.llmThinking,
       // Omit the whole block when unset so `strong` transparently falls back to
       // `fast` — the zero-config path stays byte-for-byte today's behaviour.
       ...hasStrong && {
@@ -2845,11 +3179,19 @@ function register(api) {
   const resolveAgentId2 = (ctx) => resolveAgentId(ctx, pluginConfig);
   const buildScope2 = (rawAgentId) => buildScope(rawAgentId, pluginConfig, createStorageContext);
   const defaultScope = buildScope2(resolveAgentId2());
-  const dbPath = path5.join(os2.homedir(), ".openclaw", "amem_db");
+  const dbPath = path6.join(os2.homedir(), ".openclaw", "amem_db");
+  const owedFile = path6.join(os2.homedir(), ".openclaw", "amem_nightly_owed.json");
+  const owe = (rawAgentId, since) => {
+    try {
+      markOwed(owedFile, rawAgentId, since);
+    } catch (err) {
+      logger.warn(`openclaw-amem: could not record ${rawAgentId} for the nightly merge \u2014 ${err.message}`);
+    }
+  };
   logger.info(
     `openclaw-amem: registered (native TS, Qdrant, default agent_id=${defaultScope.agentId}, default collection=${pluginConfig.collection ?? "amem_notes (default)"}, per-agent scope resolved per call)`
   );
-  ensureCollection(pluginConfig.collection).catch((e) => {
+  const checkCollection = () => ensureCollection(pluginConfig.collection).catch((e) => {
     if (e instanceof EmbeddingDimensionMismatchError || e instanceof EmbeddingModelMismatchError || e instanceof MixedEmbeddingModelsError) {
       logger.error(`openclaw-amem: memory is UNUSABLE \u2014 ${e.message}`);
     } else {
@@ -2899,7 +3241,9 @@ function register(api) {
                 },
                 async add(text) {
                   try {
+                    const since = /* @__PURE__ */ new Date();
                     await addMemory(text, scope.agentId, { storageCtx: scope.storageCtx });
+                    owe(resolveAgentId2(params), since);
                     return { ok: true };
                   } catch (err) {
                     logger.warn(`openclaw-amem: add failed \u2014 ${err.message}`);
@@ -3020,6 +3364,7 @@ ${text}${hookWarning}` }],
             const start = Date.now();
             try {
               const id = await addMemory(text, scope.agentId, { subjects, storageCtx: scope.storageCtx });
+              owe(resolveAgentId2(ctx), new Date(start));
               logger.info(`openclaw-amem: memory_add OK id=${id} (${Date.now() - start}ms)`);
               return {
                 content: [{ type: "text", text: "Memory saved successfully." }],
@@ -3146,15 +3491,30 @@ ${text}${hookWarning}` }],
   }
   if (typeof api.registerHook === "function" || typeof api.on === "function") {
     const hookFn = (typeof api.on === "function" ? api.on : api.registerHook).bind(api);
+    hookFn(
+      "before_compaction",
+      (_event, ctx) => compactionStarted(ctx)
+    );
+    hookFn(
+      "after_compaction",
+      (_event, ctx) => compactionEnded(ctx)
+    );
+    hookFn(
+      "message_received",
+      (event) => noteMessageReceived(event)
+    );
     hookFn(
       "agent_end",
       async (event, ctx) => {
+        const deadline = Date.now() + HOOK_BUDGET_MS - HOOK_MARGIN_MS;
         const scope = buildScope2(resolveAgentId2(ctx));
         const agentId = scope.agentId;
         const storageCtx = scope.storageCtx;
         logger.info(
           `openclaw-amem: agent_end hook triggered (agent_id=${agentId}, success=${event.success}, messages=${event.messages?.length ?? 0})`
         );
+        const done = foregroundWorkStarted();
+        let since;
         try {
           let shouldProcessTurn2 = function(text) {
             if (text.trim().length < 10) return false;
@@ -3190,12 +3550,18 @@ ${text}${hookWarning}` }],
           const operations = await llmCrudDecision2(
             userText,
             assistantText,
-            existingMemories.map((m) => ({ idx: m.idx, content: m.content }))
+            existingMemories.map((m) => ({ idx: m.idx, content: m.content })),
+            { deadline }
           );
           if (!operations || operations.length === 0) return;
-          for (const op of operations) {
+          since = /* @__PURE__ */ new Date();
+          for (const [i, op] of operations.entries()) {
+            if (!hasTimeFor(deadline)) {
+              logger.warn(`openclaw-amem: agent_end out of time, stored ${i} of ${operations.length} operations`);
+              break;
+            }
             if (op.action === "NEW") {
-              await addMemory(op.fact, agentId, { storageCtx });
+              await addMemory(op.fact, agentId, { storageCtx, deadline });
               logger.info(`openclaw-amem: CRUD NEW: "${op.fact.slice(0, 60)}${op.fact.length > 60 ? "..." : ""}"`);
             } else if (op.action === "UPDATE" && op.existingIdx !== void 0) {
               const target = existingMemories[op.existingIdx];
@@ -3204,7 +3570,7 @@ ${text}${hookWarning}` }],
                 const hash = (0, import_crypto2.createHash)("md5").update(op.fact).digest("hex");
                 const targetNote = await storageCtx.getNote(target.id, agentId);
                 if (!targetNote || !isPlausibleUpdateTarget(newEmbedding, targetNote.embedding, crudUpdateMinSim)) {
-                  await addMemory(op.fact, agentId, { storageCtx });
+                  await addMemory(op.fact, agentId, { storageCtx, deadline });
                   logger.warn(
                     `openclaw-amem: CRUD UPDATE on ${target.id.slice(0, 8)} looks mis-targeted \u2014 stored as a new memory instead`
                   );
@@ -3237,73 +3603,86 @@ ${text}${hookWarning}` }],
               }
             }
           }
-          const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-          logger.info(`openclaw-amem: starting mergeSimilarNotes for agent=${agentId}, date=${today}`);
-          try {
-            const merged = await mergeSimilarNotes(agentId, storageCtx);
-            if (merged > 0) {
-              logger.info(`openclaw-amem: merged ${merged} similar notes today (${today})`);
-            } else {
-              logger.info(`openclaw-amem: mergeSimilarNotes completed, 0 pairs merged (${today})`);
-            }
-          } catch (mergeErr) {
-            logger.error(
-              `openclaw-amem: mergeSimilarNotes FAILED \u2014 ${mergeErr.message}
-${mergeErr.stack}`
-            );
-          }
         } catch (e) {
           logger.warn(`openclaw-amem: agent_end CRUD hook failed \u2014 ${e.message}`);
+        } finally {
+          if (since) owe(resolveAgentId2(ctx), since);
+          done();
         }
       },
-      { timeoutMs: 3e4 }
+      { timeoutMs: HOOK_BUDGET_MS }
     );
     logger.info("openclaw-amem: agent_end CRUD decision hook registered");
   }
-  function scheduleNextRun() {
-    const now = /* @__PURE__ */ new Date();
-    const target = /* @__PURE__ */ new Date();
-    target.setHours(2, 30, 0, 0);
-    if (target.getTime() <= now.getTime()) {
-      target.setDate(target.getDate() + 1);
-    }
-    const delay = target.getTime() - now.getTime();
-    setTimeout(async () => {
-      try {
-        logger.info("openclaw-amem: Running scheduled daily consolidation...");
-        const merged = await consolidateMemories(defaultScope.agentId, logger, defaultScope.storageCtx);
-        if (merged > 0) {
-          logger.info(`openclaw-amem: Scheduled daily consolidation merged ${merged} pairs.`);
+  const nightlyJob = () => runNightly({
+    owedFile,
+    defaultAgent: resolveAgentId2(),
+    mergeDay: async (rawAgentId, day) => {
+      const scope = buildScope2(rawAgentId);
+      const merged = await mergeSimilarNotes(scope.agentId, scope.storageCtx, day);
+      if (merged > 0) logger.info(`openclaw-amem: merged ${merged} similar notes (${scope.agentId}, ${day})`);
+    },
+    after: [
+      {
+        name: "consolidation",
+        run: async () => {
+          logger.info("openclaw-amem: Running scheduled daily consolidation...");
+          const merged = await consolidateMemories(defaultScope.agentId, logger, defaultScope.storageCtx);
+          if (merged > 0) {
+            logger.info(`openclaw-amem: Scheduled daily consolidation merged ${merged} pairs.`);
+          }
         }
-      } catch (err) {
-        logger.warn(`openclaw-amem: Scheduled daily consolidation failed \u2014 ${err.message}`);
-      }
-      if (conflictSweepEnabled) {
-        try {
-          const res = await conflictSweep(defaultScope.agentId, {
-            storageCtx: defaultScope.storageCtx,
-            logger
-          });
-          if (res.pairsFound > 0) {
-            logger.info(
-              `openclaw-amem: Contradiction sweep flagged ${res.pairsFound} pair(s)` + (res.retired > 0 ? `, retired ${res.retired}` : "") + ` (${res.batchesScanned} batch(es) read, ${res.batchesSkipped} unchanged).`
-            );
+      },
+      // Story 43: the cold half of the tiering split. The per-turn CRUD decision
+      // runs on the fast model, which is safe but misses contradictions; this is
+      // what catches them. Runs AFTER consolidation, as its own step, so neither
+      // task can take the other down.
+      //
+      // Only batches that gained a note since the last run are re-read, so a
+      // steady-state night costs a call or two rather than a full re-read.
+      ...conflictSweepEnabled ? [
+        {
+          name: "contradiction sweep",
+          run: async () => {
+            const res = await conflictSweep(defaultScope.agentId, {
+              storageCtx: defaultScope.storageCtx,
+              logger
+            });
+            if (res.pairsFound > 0) {
+              logger.info(
+                `openclaw-amem: Contradiction sweep flagged ${res.pairsFound} pair(s)` + (res.retired > 0 ? `, retired ${res.retired}` : "") + ` (${res.batchesScanned} batch(es) read, ${res.batchesSkipped} unchanged).`
+              );
+            }
           }
-        } catch (err) {
-          logger.warn(`openclaw-amem: Scheduled contradiction sweep failed \u2014 ${err.message}`);
         }
-      }
-      scheduleNextRun();
-    }, delay);
-  }
-  scheduleNextRun();
+      ] : []
+    ],
+    inBackground: (work) => runInBackground(busySinceNow(), work),
+    preempted: (err) => err instanceof BackgroundPreempted,
+    logger
+  });
   if (typeof api.registerService === "function") {
     api.registerService({
       id: "amem-plugin",
       start() {
+        const events = api.runtime?.events;
+        if (typeof events?.onAgentEvent === "function") {
+          watchAgentEvents((listener) => events.onAgentEvent(listener));
+        } else {
+          logger.warn(
+            "openclaw-amem: this OpenClaw does not report runs to plugins, so the nightly job cannot wait for them"
+          );
+        }
+        scheduleNightly(
+          nightlyJob,
+          (err) => logger.warn(`openclaw-amem: nightly job failed \u2014 ${err.message}`)
+        );
+        void checkCollection();
         logger.info(`openclaw-amem: started (backend: amem-qdrant, default agentId: ${defaultScope.agentId})`);
       },
       stop() {
+        cancelNightly();
+        unwatchAgentEvents();
         logger.info("openclaw-amem: stopped");
       }
     });

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "amem",
   "description": "Catches memories that contradict each other. Notes rewrite themselves as new ones arrive, link into a graph, and stay separated per agent and per person. Runs on a small model. Requires a local Qdrant. 中文走 jieba 分词，提示词有中文版。",
   "icon": "https://amem.owo.lc/logo.png",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "kind": "memory",
   "contracts": {
     "tools": [
@@ -28,6 +28,7 @@
           "AMEM_LLM_STRONG_MODEL",
           "AMEM_LLM_STRONG_BASE_URL",
           "AMEM_LLM_CRUD_ROLE",
+          "AMEM_LLM_THINKING",
           "AMEM_CONFLICT_MODE",
           "AMEM_LLM_TIMEOUT",
           "AMEM_CRUD_UPDATE_MIN_SIM",
@@ -138,6 +139,15 @@
         "default": "fast",
         "description": "Which tier the agent_end CRUD decision runs on. Defaults to fast: it runs every turn, and its destructive failure mode is handled by the update guard rather than by model tier. Overridden by AMEM_LLM_CRUD_ROLE."
       },
+      "llmThinking": {
+        "type": "string",
+        "enum": [
+          "off",
+          "auto"
+        ],
+        "default": "off",
+        "description": "Whether fast-tier calls on the Anthropic API turn thinking off. off sends thinking disabled; a model that refuses it, such as Opus 5.5 or Fable, keeps thinking. auto sends no thinking field. Overridden by AMEM_LLM_THINKING."
+      },
       "conflictSweep": {
         "type": "boolean",
         "default": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-amem",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "Catches memories that contradict each other. Notes rewrite themselves as new ones arrive, link into a graph, and stay separated per agent and per person. Runs on a small model. Requires a local Qdrant. 中文走 jieba 分词，提示词有中文版。",
   "license": "MIT",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.122.0",
+    "@anthropic-ai/sdk": "^0.127.0",
     "@huggingface/transformers": "^4.2.0",
     "@node-rs/jieba": "^2.0.1",
     "@qdrant/js-client-rest": "^1.18.0",