openclaw-amem 2.1.1 → 2.1.3

package/README.md

@@ -10,9 +10,9 @@
 
 **Memory for [OpenClaw](https://github.com/openclaw/openclaw) agents that catches its own contradictions.**
 
-A nightly pass re-reads what changed and flags memories that no longer agree with each other — the failure mode every long-lived memory store eventually has. The rest: facts extracted instead of transcripts stored, notes rewritten as new ones arrive, linked into a Zettelkasten-style graph, retrieved with hybrid BM25 + dense search over 2-hop expansion. Memories are scoped per agent (`owner`/`readers`/`writers`) and per subject, both enforced inside the Qdrant query rather than filtered after it.
+A nightly pass re-reads what changed and flags memories that no longer agree with each other. This is the failure mode every long-lived memory store eventually has. The plugin also extracts facts instead of storing transcripts. It rewrites notes as new ones arrive, links them into a Zettelkasten-style graph, and retrieves them with hybrid BM25 + dense search over 2-hop expansion. The plugin scopes memories per agent (`owner`/`readers`/`writers`) and per subject, and enforces both inside the Qdrant query rather than filtering after it.
 
-Runs on a small model — `gpt-4o-mini`, `haiku`, a local Ollama. No Python.
+The plugin runs on a small model — `gpt-4o-mini`, `haiku`, a local Ollama. It does not require Python.
 
 中文走 [jieba](https://github.com/messense/node-jieba) 分词，提示词有完整中文版（`AMEM_PROMPT_LOCALE=zh`），embedding 模型本身多语言。
 
@@ -26,9 +26,9 @@ Requires a local [Qdrant](https://qdrant.tech). Implements [A-MEM](https://arxiv
 
 - 🔄 **Memories evolve** — new facts update/link related memories (EVOLVE / CONFLICT / EXPAND / NEW), not silent overwrite.
 - 🔍 **Hybrid retrieval** — BM25 (Jieba for Chinese) + dense vectors (RRF) + 2-hop graph expansion with a relevance gate.
-- 🧠 **Knowledge vs episodic** — durable knowledge notes skip consolidation & time-decay; topic tags for precise recall.
+- 🧠 **Knowledge vs episodic** — durable knowledge notes skip consolidation & time-decay. Topic tags for precise recall.
 - 🧹 **Self-consolidating** — daily 02:30 in-process merge of semantic duplicates with link cascading.
-- 🔐 **Per-agent isolation** — private by default; explicit `owner`/`readers`/`writers`; Mode A (shared collection) or Mode B (dedicated collection).
+- 🔐 **Per-agent isolation** — private by default. Explicit `owner`/`readers`/`writers`. Mode A (shared collection) or Mode B (dedicated collection).
 - 🀄 **Chinese-optimized** & local embeddings (Transformers.js) — no Python, no external embedding API.
 
 → Full feature list & internals: **[@amemhq/core README](../amem-core)** · **[docs](https://amem.owo.lc)**.
@@ -36,7 +36,7 @@ Requires a local [Qdrant](https://qdrant.tech). Implements [A-MEM](https://arxiv
 ## Requirements
 
 - OpenClaw v2026.4+
-- Node.js 24 (18+ works; 24/26 supported)
+- Node.js 24 (18+ works, 24/26 supported)
 - Qdrant running on `:6333`
 - An LLM: `ANTHROPIC_API_KEY` by default, or any OpenAI-compatible provider — see [LLM provider](#llm-provider)
 - ~1.1 GB of disk for the embedding model, downloaded once on first run
@@ -61,12 +61,11 @@ Updating:
 
 ```bash
 openclaw plugins update openclaw-amem
-openclaw gateway restart
 ```
 
-An update rebuilds `node_modules`, and the model cache lives there by default — so
-it re-downloads 2.27 GB unless `AMEM_MODEL_CACHE` points somewhere outside the
-plugin directory. Set that once and updates cost nothing.
+The gateway does not load the new build until it restarts. Run `openclaw gateway restart` after the update.
+
+An update rebuilds `node_modules`. The model cache lives there by default, so the plugin re-downloads 2.27 GB unless `AMEM_MODEL_CACHE` points somewhere outside the plugin directory. Set that once and updates cost nothing.
 
 ### 2. Configure `~/.openclaw/openclaw.json`
 
@@ -92,7 +91,7 @@ Add `openclaw-amem` to your allowed plugins and hook it into the `memory` slot:
 }
 ```
 
-> **⚠️ Memory slot conflict:** If your `openclaw.json` already assigns the `memory` slot to another plugin (e.g. `memory-core`), you **must** change it to `openclaw-amem`. The gateway only loads one plugin per slot — any additional `memory`-kind plugins are **silently skipped**. Set `"memory-core": { "enabled": false }` in `entries` to disable the old plugin.
+> **⚠️ Memory slot conflict:** If your `openclaw.json` already assigns the `memory` slot to another plugin (for example, `memory-core`), you **must** change it to `openclaw-amem`. On OpenClaw 2026.8.1 the slot alone is not enough. The other plugin still loads and takes the `memory_search` tool name, because the gateway loads built-in plugins before installed ones. Memory keeps working through the slot, but the tool an agent calls is then the other plugin's. Set `"memory-core": { "enabled": false }` in `entries` as well. Note that `memory-core` also writes its dream diary, and disabling it stops that too.
 
 ### 3. Restart OpenClaw
 
@@ -103,11 +102,11 @@ openclaw gateway restart
 First run downloads the embedding model (`bge-m3`, 2.27 GB) and caches it. Later
 restarts are instant. If that is too much, the only smaller model worth setting is
 `AMEM_EMBED_MODEL=Xenova/bge-small-zh-v1.5` — 25 MB, Chinese only, and it caps at
-512 tokens. Set it **before** you have memories, since changing it afterwards means
+512 tokens. Set it **before** you have memories, because changing it afterwards means
 a [migration](https://amem.owo.lc/reference/embedding-models#changing-the-model-on-a-store-you-already-have).
 
 Upgrading from 1.x downloads nothing. Your existing memories keep the model that
-built them, and the plugin says so at startup along with the one command that
+built them, and the plugin shows this at startup along with the one command that
 moves them.
 
 ## LLM provider
@@ -115,7 +114,7 @@ moves them.
 The plugin calls an LLM for note construction, linking, and evolution. Pick the backend with `AMEM_LLM_PROVIDER`:
 
 - **`anthropic`** (default) — the Anthropic Messages API. Set `ANTHROPIC_API_KEY`.
-- **`openai`** — the OpenAI Chat Completions API, which every OpenAI-compatible endpoint speaks. Set `AMEM_LLM_PROVIDER=openai`, point `AMEM_LLM_BASE_URL` at the endpoint, and set `AMEM_LLM_API_KEY` (or the standard `OPENAI_API_KEY`). Covers **OpenAI, DeepSeek, OpenRouter, Groq, Together**, and local servers (**Ollama, vLLM, LM Studio** — no key needed). Reasoning models (`o1`, `o3`, `gpt-5`) are handled automatically.
+- **`openai`** — the OpenAI Chat Completions API, which every OpenAI-compatible endpoint speaks. Set `AMEM_LLM_PROVIDER=openai`, point `AMEM_LLM_BASE_URL` at the endpoint, and set `AMEM_LLM_API_KEY` (or the standard `OPENAI_API_KEY`). Covers **OpenAI, DeepSeek, OpenRouter, Groq, Together**, and local servers (**Ollama, vLLM, LM Studio** — no key needed). The plugin handles reasoning models (`o1`, `o3`, `gpt-5`) automatically.
 
 Choose the model with `AMEM_LLM_MODEL`. Full env-var reference and examples: **[amem.owo.lc/reference/configuration](https://amem.owo.lc/reference/configuration)**.
 
@@ -142,13 +141,13 @@ Once installed, the plugin exposes five tools to the agent:
 
 ## Security & data flow
 
-A memory plugin's job is to read configuration from the environment and send memory data to backends **you** control, so registry static scanners flag its `env` + `network` pattern (e.g. ClawHub's `suspicious.env_credential_access`). This is structurally expected for any configurable memory/LLM plugin — the audit outcome is **advisory (`Review`), not `Malicious`**, and VirusTotal reports the bundle clean.
+A memory plugin's job is to read configuration from the environment and send memory data to backends **you** control, so registry static scanners flag its `env` + `network` pattern (for example, ClawHub's `suspicious.env_credential_access`). This is structurally expected for any configurable memory/LLM plugin. The audit outcome is **advisory (`Review`), not `Malicious`**, and VirusTotal reports the bundle clean.
 
 What it actually does — all of it declared in [`openclaw.plugin.json`](openclaw.plugin.json):
 
 - **Environment variables it reads** (its configuration surface, supplied by you): `AMEM_LLM_PROVIDER`, `AMEM_LLM_API_KEY`, `OPENAI_API_KEY`, `AMEM_LLM_BASE_URL`, `AMEM_LLM_MODEL`, `AMEM_COLLECTION`, `AMEM_DATA_DIR`, `AMEM_EVO_COUNTER_PATH`, `AMEM_REVIEW_DIR`, `AMEM_PROMPT_LOCALE`. No credential is bundled, hardcoded, or logged.
 - **Network destinations**: only your **local Qdrant** (`http://localhost:6333`) and your configured **LLM endpoint** (Anthropic by default, or any OpenAI-compatible endpoint via `AMEM_LLM_PROVIDER=openai` + `AMEM_LLM_BASE_URL`). It sends memory text/embeddings there to store and evolve notes — its stated purpose. It does not phone home.
-- **Conversation content** is processed for memory only when you set `hooks.allowConversationAccess: true`. Keep Qdrant and review-output paths scoped to locations you control.
+- The plugin processes **conversation content** for memory only when you set `hooks.allowConversationAccess: true`. Keep Qdrant and review-output paths scoped to locations you control.
 
 ## Development
 

package/dist/index.js

@@ -38,17 +38,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // ../amem-core/src/config.ts
 function configure(opts) {
   if (opts.dataDir) _dataDir = opts.dataDir;
+  if (opts.warn) _warn = opts.warn;
 }
 function getDataDir() {
   return _dataDir;
 }
-var os, path, _dataDir;
+function warn(msg) {
+  _warn(msg);
+}
+var os, path, _dataDir, _warn;
 var init_config = __esm({
   "../amem-core/src/config.ts"() {
     "use strict";
     os = __toESM(require("os"), 1);
     path = __toESM(require("path"), 1);
     _dataDir = process.env.AMEM_DATA_DIR || path.join(os.homedir(), ".amem");
+    _warn = (msg) => console.warn(msg);
   }
 });
 
@@ -87,6 +92,12 @@ function applyModelPaths(env) {
     env.allowLocalModels = true;
   }
 }
+function humanBytes(n) {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(2)} GB`;
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)} MB`;
+  if (n >= 1e3) return `${Math.round(n / 1e3)} kB`;
+  return `${n} B`;
+}
 function makeProgressReporter() {
   const lastPct = /* @__PURE__ */ new Map();
   return (e) => {
@@ -95,7 +106,7 @@ function makeProgressReporter() {
     const pct = Math.floor(e.progress / 10) * 10;
     if (lastPct.get(e.file) === pct) return;
     lastPct.set(e.file, pct);
-    const size = e.total ? ` of ${(e.total / 1e9).toFixed(2)} GB` : "";
+    const size = e.total ? ` of ${humanBytes(e.total)}` : "";
     console.log(`[amem] downloading ${e.file}: ${pct}%${size}`);
   };
 }
@@ -246,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;
 }
@@ -294,7 +305,7 @@ async function ensureCollection(collectionName) {
       if (inUse !== null && inUse !== wanted) throw new MixedEmbeddingModelsError(col, wanted, inUse);
       pinEmbeddingModel(wanted);
       if (wanted === LEGACY_DEFAULT_EMBEDDING_MODEL) {
-        console.warn(
+        warn(
           `[amem] "${col}" is on ${LEGACY_DEFAULT_EMBEDDING_MODEL} (${LEGACY_DEFAULT_DIM}-dim).
 [amem] ${DEFAULT_EMBEDDING_MODEL} reads 8192 tokens where that one stops at 128, so anything longer is being truncated before it reaches the vector.
 [amem] To move: npx --package=@amemhq/core amem-migrate --from-collection ${col}`
@@ -307,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;
@@ -698,7 +709,7 @@ function makeCrud(collectionName, modeBIsolated = false) {
             })
           )
         ]).catch((err) => {
-          console.error(`[amem] retrieval tracking patch failed: ${err.message}`);
+          warn(`[amem] retrieval tracking patch failed: ${err.message}`);
         });
         for (const r of queryResults) {
           r.note.retrieval_count = (r.note.retrieval_count || 0) + 1;
@@ -818,6 +829,7 @@ var init_storage = __esm({
   "../amem-core/src/storage.ts"() {
     "use strict";
     init_auth();
+    init_config();
     init_embedding();
     QDRANT_URL = "http://localhost:6333";
     getCollection = () => process.env.AMEM_COLLECTION || "amem_notes";
@@ -1119,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 };
@@ -1128,7 +1179,7 @@ function configureLlm(cfg) {
 function warnOnce(key, message) {
   if (_warned.has(key)) return;
   _warned.add(key);
-  console.error(message);
+  warn(message);
 }
 function resolveProvider(role = "fast") {
   const raw = role === "strong" ? process.env.AMEM_LLM_STRONG_PROVIDER || _override.strong?.provider || void 0 : void 0;
@@ -1154,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;
@@ -1190,37 +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 {
-    return 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})`);
   } catch (e) {
-    console.error(`[amem] LLM call failed: ${e.message}`);
-    return null;
+    warn(`[amem] LLM call failed: ${e.message}`);
   }
+  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) {
@@ -1252,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"],
@@ -1287,8 +1377,9 @@ confidence guide (Story 27):
 - low: LLM is uncertain \u2014 vague, fragmentary, or mixed content
 
 Text: ${content}`;
-  const raw = await llmCall(prompt, 400);
-  if (!raw)
+  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 {
       keywords: [],
       tags: [],
@@ -1298,6 +1389,7 @@ Text: ${content}`;
       topics: [],
       confidence: "medium"
     };
+  }
   try {
     const data = parseJsonLoose(raw);
     const rawCategory = typeof data.category === "string" ? data.category : "General";
@@ -1316,7 +1408,7 @@ Text: ${content}`;
       confidence
     };
   } catch (e) {
-    console.error(`[amem] Note construction parse failed: ${e.message}`);
+    warn(`[amem] Note construction parse failed: ${e.message}`);
     return {
       keywords: [],
       tags: [],
@@ -1328,26 +1420,32 @@ 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) return [];
+    if (!match) {
+      warn("[amem] llmCrudDecision found no array in the response; nothing from this turn is stored");
+      return [];
+    }
     const parsed = JSON.parse(match[0]);
-    if (!Array.isArray(parsed)) return [];
+    if (!Array.isArray(parsed)) {
+      warn("[amem] llmCrudDecision parsed a non-array; nothing from this turn is stored");
+      return [];
+    }
     const ops = [];
     for (const item of parsed) {
       if (!item || typeof item !== "object") continue;
@@ -1366,7 +1464,7 @@ async function llmCrudDecision(userText, assistantText, existingMemories) {
     }
     return ops.slice(0, 3);
   } catch (e) {
-    console.error(`[amem] llmCrudDecision failed: ${e.message}`);
+    warn(`[amem] llmCrudDecision failed: ${e.message}`);
     return [];
   }
 }
@@ -1376,20 +1474,26 @@ async function llmShouldMerge(contentA, contentB) {
   if (!raw) return { shouldMerge: false };
   try {
     const data = parseJsonLoose(raw);
-    if (typeof data.shouldMerge !== "boolean") return { shouldMerge: false };
+    if (typeof data.shouldMerge !== "boolean") {
+      warn("[amem] llmShouldMerge got no boolean verdict; treating the pair as distinct");
+      return { shouldMerge: false };
+    }
     if (data.shouldMerge && typeof data.merged === "string") {
       return { shouldMerge: true, merged: data.merged };
     }
     return { shouldMerge: false };
   } catch (e) {
-    console.error(`[amem] llmShouldMerge parse failed: ${e.message}`);
+    warn(`[amem] llmShouldMerge parse failed: ${e.message}`);
     return { shouldMerge: false };
   }
 }
 async function llmEvolutionJudge(oldContent, newContent) {
   const prompt = t.evolutionJudge(oldContent, newContent);
   const raw = await llmCall(prompt, 300, "strong");
-  if (!raw) return { type: "NEW" };
+  if (!raw) {
+    warn("[amem] evolution judge got nothing back; defaulting the pair to NEW");
+    return { type: "NEW" };
+  }
   try {
     const data = parseJsonLoose(raw);
     const type = VALID_EVOLUTION_TYPES.has(data.type) ? data.type : "NEW";
@@ -1398,11 +1502,11 @@ async function llmEvolutionJudge(oldContent, newContent) {
       mergedContent: typeof data.mergedContent === "string" ? data.mergedContent : void 0
     };
   } catch (e) {
-    console.error(`[amem] llmEvolutionJudge parse failed: ${e.message}`);
+    warn(`[amem] llmEvolutionJudge parse failed: ${e.message}`);
     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.
@@ -1425,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);
@@ -1437,21 +1541,27 @@ ${linkedStr}`;
       tagsToUpdate: Array.isArray(data.tags_to_update) ? data.tags_to_update.map(String) : []
     };
   } catch (e) {
-    console.error(`[amem] Evolution parse failed: ${e.message}`);
+    warn(`[amem] Evolution parse failed: ${e.message}`);
     return { tags: null, context: null, shouldStrengthen: false, suggestedConnections: [], tagsToUpdate: [] };
   }
 }
 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) return [];
+    if (!match) {
+      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)) return [];
+    if (!Array.isArray(parsed)) {
+      warn("[amem] llmConflictScan parsed a non-array; the batch is read again next run");
+      return null;
+    }
     const pairs = [];
     const seen = /* @__PURE__ */ new Set();
     for (const item of parsed) {
@@ -1473,21 +1583,30 @@ 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) {
-    console.error(`[amem] llmConflictScan failed: ${e.message}`);
-    return [];
+    warn(`[amem] llmConflictScan failed: ${e.message}`);
+    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";
     import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
     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();
@@ -1624,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}`);
@@ -1697,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);
@@ -1722,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)) {
@@ -1743,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;
@@ -1817,7 +1939,7 @@ async function addMemory(content, agentId = "main", opts) {
       }
     }
   } catch (e) {
-    console.error(`[warn] Link/Evolution phase failed: ${e.message}`);
+    warn(`[amem] link/evolution phase failed: ${e.message}`);
   }
   console.log(`[done] Note added: ${note.id}`);
   return note.id;
@@ -1964,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;
@@ -1985,6 +2106,7 @@ async function mergeSimilarNotes(agentId, storageCtx) {
       }
     }
     if (!bestNeighbor) {
+      stopIfForegroundBusy();
       await ctx.patchNotePayload(pendingNote.id, { pending_merge: false });
       continue;
     }
@@ -2083,8 +2205,8 @@ async function consolidateMemories(agentId, logger, storageCtx) {
   const ctx = storageCtx ?? defaultCtx();
   const log = {
     info: (msg) => logger ? logger.info(msg) : console.log(msg),
-    warn: (msg) => logger ? logger.warn(msg) : console.warn(msg),
-    error: (msg) => logger ? logger.error(msg) : console.error(msg)
+    warn: (msg) => logger ? logger.warn(msg) : warn(msg),
+    error: (msg) => logger ? logger.error(msg) : warn(msg)
   };
   log.info(`[Consolidation] Starting consolidation for agentId: ${agentId}`);
   const rawNotes = await ctx.listNotes(agentId);
@@ -2105,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];
@@ -2214,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) {
@@ -2225,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];
@@ -2263,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({
@@ -2280,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, "");
@@ -2488,7 +2618,7 @@ async function migrateCollection(opts) {
   const refreshFields = opts.refreshFields !== false;
   const dryRun = opts.dryRun !== false;
   const log = opts.logger?.info ?? ((m) => console.log(m));
-  const warn = opts.logger?.warn ?? ((m) => console.warn(m));
+  const warn2 = opts.logger?.warn ?? warn;
   if (from === to) throw new Error(`migrate: source and target are the same collection ("${from}")`);
   const model = getEmbeddingModel();
   const targetDim = await getEmbeddingDim();
@@ -2556,7 +2686,7 @@ async function migrateCollection(opts) {
         if (!note.context) note.context = built.context;
         refreshed++;
       } catch (e) {
-        warn(`[migrate] re-extract failed for ${note.id.slice(0, 8)} \u2014 keeping as-is: ${e.message}`);
+        warn2(`[migrate] re-extract failed for ${note.id.slice(0, 8)} \u2014 keeping as-is: ${e.message}`);
       }
     }
     const point = noteToPoint({ ...note, embedding: await encode(buildEmbedText(note)) });
@@ -2569,7 +2699,7 @@ async function migrateCollection(opts) {
   await flush();
   const finalCount = await countPointsRaw(to);
   if (finalCount !== notes.length) {
-    warn(`[migrate] target holds ${finalCount} point(s) but the source had ${notes.length} \u2014 check before switching`);
+    warn2(`[migrate] target holds ${finalCount} point(s) but the source had ${notes.length} \u2014 check before switching`);
   }
   log(`[migrate] done: ${migrated} written, ${alreadyDone.size} already present, ${refreshed} re-extracted.`);
   return {
@@ -2624,6 +2754,7 @@ var init_migrate = __esm({
     init_embedding();
     init_llm();
     init_memory();
+    init_config();
   }
 });
 
@@ -2651,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,
@@ -2679,6 +2811,7 @@ __export(src_exports, {
   getEmbeddingModel: () => getEmbeddingModel,
   getEmbeddingPooling: () => getEmbeddingPooling,
   getNote: () => getNote,
+  hasTimeFor: () => hasTimeFor,
   invalidateNote: () => invalidateNote,
   isModelLoaded: () => isModelLoaded,
   isPlausibleUpdateTarget: () => isPlausibleUpdateTarget,
@@ -2691,6 +2824,7 @@ __export(src_exports, {
   patchNotePayload: () => patchNotePayload,
   pingQdrant: () => pingQdrant,
   resolveCrudUpdateMinSim: () => resolveCrudUpdateMinSim,
+  runInBackground: () => runInBackground,
   scanLowQuality: () => scanLowQuality,
   searchMemory: () => searchMemory,
   switchToMigrated: () => switchToMigrated,
@@ -2711,6 +2845,8 @@ var init_src = __esm({
     init_memory();
     init_crud_guard();
     init_llm();
+    init_deadline();
+    init_background();
   }
 });
 
@@ -2737,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");
@@ -2750,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;
@@ -2775,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 || {};
@@ -2782,14 +3151,18 @@ function register(api) {
   const pluginId = api.id ?? "openclaw-amem";
   const convBlocked = isConvAccessBlocked(api.config, pluginId);
   if (convBlocked) logger.warn(BLOCKED_WARNING_LOG);
-  configure({ dataDir: path5.join(os2.homedir(), ".openclaw") });
+  configure({
+    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 && {
@@ -2806,7 +3179,15 @@ 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)`
   );
@@ -2860,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}`);
@@ -2981,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." }],
@@ -3107,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;
@@ -3132,7 +3531,12 @@ ${text}${hookWarning}` }],
           const msgs = event.messages || [];
           const lastUser = [...msgs].reverse().find((m) => m.role === "user");
           const lastAssistant = [...msgs].reverse().find((m) => m.role === "assistant");
-          if (!lastUser || !lastAssistant) return;
+          if (!lastUser || !lastAssistant) {
+            logger.info(
+              `openclaw-amem: agent_end skipped \u2014 no ${!lastUser ? "user" : "assistant"} message in ${msgs.length} messages`
+            );
+            return;
+          }
           const userText = typeof lastUser.content === "string" ? lastUser.content : lastUser.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
           const assistantText = typeof lastAssistant.content === "string" ? lastAssistant.content : lastAssistant.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
           if (!userText || !shouldProcessTurn2(userText)) return;
@@ -3146,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];
@@ -3160,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`
                   );
@@ -3193,73 +3603,84 @@ ${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.`);
-        }
-      } 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).`
-            );
+  scheduleNightly(
+    () => 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 contradiction sweep failed \u2014 ${err.message}`);
-        }
-      }
-      scheduleNextRun();
-    }, delay);
-  }
-  scheduleNextRun();
+        },
+        // 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).`
+                );
+              }
+            }
+          }
+        ] : []
+      ],
+      inBackground: (work) => runInBackground(busySinceNow(), work),
+      preempted: (err) => err instanceof BackgroundPreempted,
+      logger
+    }),
+    (err) => logger.warn(`openclaw-amem: nightly job failed \u2014 ${err.message}`)
+  );
   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"
+          );
+        }
         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.1",
+  "version": "2.1.3",
   "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.1",
+  "version": "2.1.3",
   "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.112.5",
+    "@anthropic-ai/sdk": "^0.126.0",
     "@huggingface/transformers": "^4.2.0",
     "@node-rs/jieba": "^2.0.1",
     "@qdrant/js-client-rest": "^1.18.0",