@nowledge/openclaw-nowledge-mem 0.7.1 → 0.8.1

package/CHANGELOG.md

@@ -2,7 +2,49 @@
 
 All notable changes to the Nowledge Mem OpenClaw plugin will be documented in this file.
 
-## [Unreleased]
+## [0.8.1] - 2026-04-07
+
+### Fixed
+
+- **Thread provenance linking now handles API response shape.** The backend returns `source_thread` as an `{id, title}` object, but `_normalizeMemory` and `memory-get.js` assigned it directly to `sourceThreadId`, producing `[object Object]` instead of a usable thread ID. Both paths now extract the `.id` string, with fallbacks for the CLI string format and metadata `source_thread_id`.
+- **Child process env no longer leaks `"undefined"` strings.** `spawn-env.js` set `NMEM_API_URL` and `NMEM_API_KEY` to JavaScript `undefined` to clear inherited values, but Node's `child_process` stringifies that to the literal `"undefined"`. Now uses `delete` to properly remove the keys.
+
+## [0.8.0] - 2026-04-07
+
+### Fixed
+
+- **Cron and isolated-agent runs no longer sync into Mem threads by default.** OpenClaw schedules these as `agent:<agentId>:cron:...` (for example the `cron-worker` agent). They were previously captured like normal chat because `captureExclude` defaulted to empty and segment-based globs do not cover variable-depth keys. The plugin now calls OpenClaw's published `isCronSessionKey` from `openclaw/plugin-sdk/routing` (available since v2026.3.22, no duplicated parsing logic), also skips bare `cron:*` internal keys that the SDK does not classify, and applies this in hook handlers and Context Engine `afterTurn` (thread append + distillation).
+
+### Added
+
+
+- **Corpus supplement for OpenClaw dreaming.** Nowledge Mem's knowledge graph now participates in memory-core's recall pipeline and dreaming promotion. When `corpusSupplement: true` is set, memories stored in Nowledge Mem are searchable through memory-core's native `memory_search` tool and its three-phase dreaming system (light, deep, REM). Recalled Nowledge Mem content accumulates frequency, relevance, and diversity scores that feed into deep-phase promotion decisions. Cross-tool knowledge organically strengthens OpenClaw's local workspace memory.
+
+  Enable in your OpenClaw config:
+  ```json
+  { "corpusSupplement": true }
+  ```
+
+  Three new config keys control the supplement: `corpusSupplement` (boolean, default false), `corpusMaxResults` (1-20, default 5), `corpusMinScore` (0-100%, default 0).
+
+- **Duplicate recall prevention.** When the corpus supplement is active, the plugin's own search-based recall (in the hook and Context Engine) is automatically disabled. Working Memory injection continues as before. This prevents the same memories from appearing twice in the agent's context.
+
+### Changed
+
+- **Minimum OpenClaw version bumped to `>=2026.4.5`** for `registerMemoryCorpusSupplement` API support. Graceful fallback for older versions (registration silently skipped).
+
+## [0.7.3] - 2026-03-30
+
+### Added
+
+- **Status tool now checks plugin trust and memory slot.** `nowledge_mem_status` reads `plugins.allow` from the OpenClaw config: warns when the allowlist exists but the plugin is missing (loading will be blocked); shows a tip when no allowlist is set (plugin loads via `entries.enabled`, but trust is implicit). Also warns when the memory slot points to `memory-core` instead of `openclaw-nowledge-mem` — a common misconfiguration after upgrading to OpenClaw 3.22+. Both checks include the exact fix command.
+- **Clarified that no `tools.*` config is needed.** All plugin tools register automatically when the plugin loads. Listing `nowledge_mem_*` names in `tools.allow` is a misconfiguration — OpenClaw silently strips allowlists that contain only plugin entries. The only config users need is `plugins.allow: ["openclaw-nowledge-mem"]`. Updated troubleshooting in README, SKILL.md, and website docs (EN + ZH).
+
+## [0.7.2] - 2026-03-30
+
+### Added
+
+- **Status tool now reports memory slot configuration.** `nowledge_mem_status` checks whether the OpenClaw memory slot points to `openclaw-nowledge-mem`. If another plugin (e.g. the built-in `memory-core`) holds the slot, the tool shows a warning with the fix command. This catches a common misconfiguration after upgrading to OpenClaw 3.22+, where the implicit slot default changed to `memory-core`.
 
 ### Fixed
 

package/CLAUDE.md

@@ -7,7 +7,7 @@ Continuation guide for `community/nowledge-mem-openclaw-plugin`.
 - Plugin target: OpenClaw plugin runtime (memory slot + context engine)
 - Runtime: JS ESM modules under `src/`, no TS build pipeline
 - Memory backend: `nmem` CLI (fallback: `uvx --from nmem-cli nmem`)
-- OpenClaw minimum: `2026.3.7` (`appendSystemContext` / system-context guidance required)
+- OpenClaw minimum: `2026.4.5` (`registerMemoryCorpusSupplement` for dreaming integration)
 - Architecture: **CLI-first via OpenClaw runtime** - all CLI execution goes through `api.runtime.system.runCommandWithTimeout`, not direct `child_process`
 - Context engine: registered via `api.registerContextEngine("nowledge-mem", factory)`. Activated when user sets `plugins.slots.contextEngine: "nowledge-mem"`. Falls back to hooks when CE is not active.
 - Remote mode: `~/.nowledge-mem/config.json` (shared) or OpenClaw dashboard. Legacy `openclaw.json` still honored.
@@ -34,6 +34,7 @@ src/
   client.js         - CLI wrapper with API fallback; async runtime command execution; credential handling
   spawn-env.js      - env-only credential injection for the nmem runner
   config.js         - config cascade: openclaw.json (legacy) > pluginConfig > config.json (credentials) > env > defaults
+  corpus-supplement.js - MemoryCorpusSupplement for memory-core dreaming pipeline; search + get backed by nmem
   hooks/
     behavioral.js   - always-on behavioral guidance (~50 tokens/turn); no-ops when CE active
     recall.js       - before_prompt_build: inject Working Memory + recalled memories; no-ops when CE active
@@ -56,6 +57,28 @@ openclaw.plugin.json - manifest + config schema (version, uiHints, configSchema,
 ~/.nowledge-mem/config.json   - shared credentials (apiUrl/apiKey) read by all Nowledge Mem tools
 ```
 
+## Corpus Supplement (Dreaming Integration)
+
+When `corpusSupplement: true`, the plugin registers a `MemoryCorpusSupplement` via `api.registerMemoryCorpusSupplement()`. This makes Nowledge Mem's knowledge graph searchable through memory-core's recall pipeline, including its three-phase dreaming system (light, deep, REM).
+
+### How it works
+
+1. **Recall**: When memory-core's `memory_search` runs, it fans out to all registered corpus supplements. Our supplement calls `client.search()` and maps results to `MemoryCorpusSearchResult` format.
+2. **Dreaming**: Recalled Nowledge Mem content accumulates frequency, relevance, and diversity scores in memory-core's short-term recall store. High-scoring content is promoted to `MEMORY.md` during deep-phase dreaming.
+3. **Dedup**: When active, the recall hook and CE `assemble()` skip their own search-based recall (memories section only). Working Memory injection continues as before.
+
+### When to enable
+
+Enable when memory-core is the memory slot and you want cross-tool knowledge to participate in OpenClaw's native recall and dreaming. Most users have Nowledge Mem as the memory slot (default `false`).
+
+### Config keys
+
+| Key | Type | Default | Env Var | Description |
+|-----|------|---------|---------|-------------|
+| `corpusSupplement` | boolean | `false` | `NMEM_CORPUS_SUPPLEMENT` | Register as corpus supplement |
+| `corpusMaxResults` | integer 1-20 | `5` | `NMEM_CORPUS_MAX_RESULTS` | Max results per search call |
+| `corpusMinScore` | integer 0-100 | `0` | `NMEM_CORPUS_MIN_SCORE` | Min score filter (0 = include all) |
+
 ## Context Engine (CE) Architecture
 
 The plugin registers both a **memory slot** (`kind: "memory"`) and a **context engine** (`api.registerContextEngine`). These are independent registrations:
@@ -118,7 +141,7 @@ When `contextEngine` points elsewhere (or is absent), hooks handle everything. N
 - `nowledge_mem_thread_fetch` - fetch messages from a specific thread. Start with a small page, then use `offset` + `limit` for progressive retrieval only when more context is needed.
 
 ### Diagnostics
-- `nowledge_mem_status` - show effective config (mode, apiUrl, apiKey set, sessionContext, sessionDigest, etc.), backend connectivity, and version. No parameters.
+- `nowledge_mem_status` - show plugin trust status, memory slot status, effective config (mode, apiUrl, apiKey set, sessionContext, sessionDigest, etc.), backend connectivity, and version. Checks `plugins.allow`: warns if set but plugin not included (loading blocked); shows tip if not set (plugin loads via `entries.enabled` but trust is implicit). Warns if the memory slot points to `memory-core` instead of `openclaw-nowledge-mem` (common after OpenClaw 3.22+ upgrade). No parameters.
 
 ## Skill Surface
 
@@ -151,6 +174,11 @@ Credentials (apiUrl/apiKey): also reads `~/.nowledge-mem/config.json` (shared wi
 | `maxContextResults` | integer 1-20 | `5` | `NMEM_MAX_CONTEXT_RESULTS` | How many memories to inject at prompt time |
 | `recallMinScore` | integer 0-100 | `0` | `NMEM_RECALL_MIN_SCORE` | Min relevance score (%) to include in auto-recall |
 | `maxThreadMessageChars` | integer 200-20000 | `800` | `NMEM_MAX_THREAD_MESSAGE_CHARS` | Max chars per captured thread message before truncation |
+| `captureExclude` | string[] | `[]` | — | Session key glob patterns to skip during auto-capture. `*` matches within a colon-segment. Example: `["agent:*:cron:*"]` |
+| `captureSkipMarker` | string | `"#nmem-skip"` | — | In-band marker: any message containing this text skips capture for the session. Not sticky across compaction |
+| `corpusSupplement` | boolean | `false` | `NMEM_CORPUS_SUPPLEMENT` | Register as MemoryCorpusSupplement for memory-core recall + dreaming |
+| `corpusMaxResults` | integer 1-20 | `5` | `NMEM_CORPUS_MAX_RESULTS` | Max results per corpus supplement search |
+| `corpusMinScore` | integer 0-100 | `0` | `NMEM_CORPUS_MIN_SCORE` | Min score for supplement results (0 = all) |
 | `apiUrl` | string | `""` | `NMEM_API_URL` | Remote server URL. Empty = local (127.0.0.1:14242) |
 | `apiKey` | string | `""` | `NMEM_API_KEY` | API key. Never logged. |
 

package/README.md

@@ -9,7 +9,7 @@ This is not a flat note store. Nowledge Mem links related knowledge into a graph
 ## Requirements
 
 - [Nowledge Mem](https://mem.nowledge.co) desktop app **or** `nmem` CLI
-- [OpenClaw](https://openclaw.ai) >= 2026.3.7
+- [OpenClaw](https://openclaw.ai) >= 2026.4.5 (corpus supplement requires this version; core features work on >= 2026.3.7)
 
 ## Installation
 
@@ -187,6 +187,20 @@ Two entry points:
 1. **From a memory**: `memory_search` or `memory_get` returns `sourceThreadId`, then fetch the source conversation
 2. **Direct search**: `nowledge_mem_thread_search` finds conversations by keyword, then fetch any result
 
+### Corpus Supplement (Dreaming Integration)
+
+When OpenClaw's memory-core is the primary memory slot and Nowledge Mem runs alongside it, you can enable `corpusSupplement: true`. This registers Nowledge Mem as a searchable corpus inside memory-core's recall pipeline and three-phase dreaming system (light, deep, REM).
+
+**What happens:**
+- Every time memory-core runs `memory_search`, it also searches Nowledge Mem's knowledge graph via the supplement.
+- Recalled Nowledge Mem content accumulates frequency and relevance scores in memory-core's short-term store.
+- High-scoring content is promoted to `MEMORY.md` during deep-phase dreaming (daily, 3 AM).
+- The plugin's own search-based recall is automatically disabled to avoid duplicates. Working Memory injection continues as before.
+
+**When to enable:** When memory-core is the memory slot and you want your cross-tool knowledge graph to participate in OpenClaw's native dreaming cycle. Most users have Nowledge Mem as the memory slot directly, so this defaults to `false`.
+
+Requires OpenClaw >= 2026.4.5.
+
 ### Three Modes at a Glance
 
 ```mermaid
@@ -372,6 +386,9 @@ To change settings, use the OpenClaw plugin settings UI. Changes take effect on
 | `maxContextResults` | integer | `5` | Max memories to inject at prompt time (1-20, only used when sessionContext is enabled) |
 | `recallMinScore` | integer | `0` | Min relevance score (0-100%) to include in auto-recall. 0 = include all |
 | `maxThreadMessageChars` | integer | `800` | Maximum characters preserved per captured OpenClaw thread message before truncation |
+| `corpusSupplement` | boolean | `false` | Register as a searchable corpus inside memory-core's recall and dreaming pipeline |
+| `corpusMaxResults` | integer | `5` | Max results per corpus supplement search (1-20) |
+| `corpusMinScore` | integer | `0` | Min relevance score (0-100%) for supplement results. 0 = include all |
 | `apiUrl` | string | `""` | Remote server URL. Empty = local (`http://127.0.0.1:14242`) |
 | `apiKey` | string | `""` | API key for remote access. Injected as `NMEM_API_KEY` env var, never logged |
 
@@ -399,6 +416,9 @@ NMEM_DIGEST_MIN_INTERVAL=300
 NMEM_MAX_CONTEXT_RESULTS=5
 NMEM_RECALL_MIN_SCORE=0
 NMEM_MAX_THREAD_MESSAGE_CHARS=800
+NMEM_CORPUS_SUPPLEMENT=false
+NMEM_CORPUS_MAX_RESULTS=5
+NMEM_CORPUS_MIN_SCORE=0
 NMEM_API_URL=https://...
 NMEM_API_KEY=your-key
 ```
@@ -433,6 +453,56 @@ If OpenClaw logs a warning like `plugins.allow is empty; discovered non-bundled
 
 If you also use linked or workspace copies, review `plugins.load.paths` before relying on an allowlist. OpenClaw allowlists plugin ids, not install provenance.
 
+## Troubleshooting
+
+**Only `memory_search` and `memory_get` show up — saves go to local markdown files**
+
+The memory slot is probably still set to the built-in `memory-core`. OpenClaw 3.22+ defaults to `memory-core` when no explicit slot is configured. Reinstall to reset the slot automatically:
+
+```bash
+openclaw plugins install @nowledge/openclaw-nowledge-mem
+```
+
+Or set the slot manually in `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "slots": { "memory": "openclaw-nowledge-mem" }
+  }
+}
+```
+
+Restart OpenClaw after either change.
+
+**Plugin tools not available**
+
+All 10 plugin tools register automatically when the plugin loads. No tool-level config is needed — just make sure the plugin itself is trusted:
+
+```json
+{
+  "plugins": {
+    "allow": ["openclaw-nowledge-mem"]
+  }
+}
+```
+
+If `openclaw status` shows a CRITICAL warning about `plugins.allow`, this is the fix. Run `nowledge_mem_status` inside a conversation to check both plugin trust and memory slot status.
+
+Do not list `nowledge_mem_*` tool names in `tools.allow` — OpenClaw silently strips allowlists that contain only plugin entries, so the config looks active but does nothing.
+
+**Search timeouts with many concurrent agents**
+
+When running many agents in parallel, all searches share a single database connection. Upgrade to Nowledge Mem v0.6.12+ (backend) so scoring writes no longer block search responses.
+
+**`nmem --json status` fails in local mode**
+
+The Nowledge Mem backend is not running. Start it from the desktop app, or run the backend manually.
+
+**Remote mode not connecting**
+
+Check `~/.nowledge-mem/config.json` credentials. Run `nmem --json --api-url "$URL" status` to verify the server is reachable.
+
 ## What Makes This Different
 
 - **Local-first**: no API key, no cloud account. Your knowledge stays on your machine.

package/SKILL.md

@@ -186,6 +186,18 @@ First check the plugin status:
 openclaw nowledge-mem status
 ```
 
+If only `memory_search` and `memory_get` tools are available (other Nowledge Mem tools missing), the memory slot may still point to the built-in `memory-core`. Verify the slot in `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "slots": { "memory": "openclaw-nowledge-mem" }
+  }
+}
+```
+
+If missing, reinstall (`openclaw plugins install @nowledge/openclaw-nowledge-mem`) which sets the slot automatically. This is common after upgrading OpenClaw to 3.22+ where the default memory slot changed.
+
 Then verify in chat.
 
 For a clean synthetic check:
@@ -237,6 +249,7 @@ What to expect:
 | `plugins.allow is empty` warning | Add `openclaw-nowledge-mem` to `plugins.allow` if the user wants explicit trust |
 | Remote config seems ignored | Check whether `~/.nowledge-mem/openclaw.json` is overriding plugin settings |
 | Local mode unexpectedly talks to a remote server | Check for stale `NMEM_API_URL` / `NMEM_API_KEY` in the environment or an overriding `~/.nowledge-mem/openclaw.json` |
+| Plugin tools missing | Ensure the plugin is in `plugins.allow: ["openclaw-nowledge-mem"]`. Do **not** put `nowledge_mem_*` tool names in `tools.allow` — OpenClaw silently strips plugin-only allowlists. No `tools.*` config is needed; plugin tools load automatically when the plugin is allowed. |
 
 ## Notes for Agents
 

package/openclaw.plugin.json

@@ -1,8 +1,10 @@
 {
 	"id": "openclaw-nowledge-mem",
-	"version": "0.7.1",
+	"version": "0.8.1",
 	"kind": "memory",
-	"skills": ["skills/memory-guide"],
+	"skills": [
+		"skills/memory-guide"
+	],
 	"uiHints": {
 		"sessionContext": {
 			"label": "Session context injection",
@@ -28,6 +30,26 @@
 			"label": "Max thread message chars",
 			"help": "Maximum characters preserved per captured OpenClaw thread message (200-20000). Higher values keep more of long messages in Nowledge thread history."
 		},
+		"captureExclude": {
+			"label": "Exclude session patterns",
+			"help": "Extra session key glob patterns to skip during auto-capture (* = one colon segment). OpenClaw cron / isolated automation sessions are always excluded using the host's own session classification\u2014no patterns required. Use this list for subagents or other sessions you want to filter."
+		},
+		"captureSkipMarker": {
+			"label": "Skip marker",
+			"help": "Text marker in messages that prevents capture for the session. Default: #nmem-skip. Note: if compaction drops the marked message, capture resumes \u2014 use captureExclude patterns for persistent filtering."
+		},
+		"corpusSupplement": {
+			"label": "Register as corpus supplement",
+			"help": "Make Nowledge Mem searchable through memory-core's recall pipeline and dreaming promotion. Enable when memory-core is your memory slot and you want cross-tool knowledge to participate in OpenClaw's native recall and dreaming. When enabled, the plugin's own search-based recall is skipped to avoid duplicates (Working Memory injection continues)."
+		},
+		"corpusMaxResults": {
+			"label": "Corpus supplement max results",
+			"help": "Maximum results returned per corpus supplement search call (1-20). Only used when corpusSupplement is enabled."
+		},
+		"corpusMinScore": {
+			"label": "Corpus supplement min score (%)",
+			"help": "Minimum relevance score (0-100%) for corpus supplement results. Set to 0 to include all. Only used when corpusSupplement is enabled."
+		},
 		"apiUrl": {
 			"label": "Server URL (remote mode)",
 			"help": "Leave empty for local mode (default: http://127.0.0.1:14242). Set to your remote server URL for cross-device or team access. See: https://docs.nowledge.co/docs/remote-access"
@@ -79,6 +101,38 @@
 				"maximum": 20000,
 				"description": "Maximum characters preserved per captured OpenClaw thread message before truncation."
 			},
+			"captureExclude": {
+				"type": "array",
+				"items": {
+					"type": "string"
+				},
+				"default": [],
+				"description": "Additional glob patterns to exclude from auto-capture (* = one colon segment). Cron and isolated automation are always excluded via OpenClaw's isCronSessionKey (plugin-sdk/routing) plus bare cron:* internal keys."
+			},
+			"captureSkipMarker": {
+				"type": "string",
+				"default": "#nmem-skip",
+				"description": "Text marker in messages that prevents capture for the entire session. When any message contains this marker, the session is skipped. Note: compaction may drop the marked message \u2014 use captureExclude for persistent filtering."
+			},
+			"corpusSupplement": {
+				"type": "boolean",
+				"default": false,
+				"description": "Register Nowledge Mem as a MemoryCorpusSupplement for memory-core's recall pipeline and dreaming. Enable when memory-core is your memory slot."
+			},
+			"corpusMaxResults": {
+				"type": "integer",
+				"default": 5,
+				"minimum": 1,
+				"maximum": 20,
+				"description": "Maximum results per corpus supplement search call (only used when corpusSupplement is enabled)"
+			},
+			"corpusMinScore": {
+				"type": "integer",
+				"default": 0,
+				"minimum": 0,
+				"maximum": 100,
+				"description": "Minimum relevance score (0-100%) for corpus supplement results (only used when corpusSupplement is enabled)"
+			},
 			"apiUrl": {
 				"type": "string",
 				"default": "",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nowledge/openclaw-nowledge-mem",
-	"version": "0.7.1",
+	"version": "0.8.1",
 	"type": "module",
 	"description": "Nowledge Mem memory plugin for OpenClaw, local-first personal knowledge base",
 	"author": {
@@ -32,7 +32,7 @@
 		"format": "biome format --write ."
 	},
 	"peerDependencies": {
-		"openclaw": ">=2026.3.7"
+		"openclaw": ">=2026.4.5"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.0"

package/src/client.js

@@ -396,9 +396,11 @@ export class NowledgeMemClient {
 			eventEnd: m.event_end ?? null,
 			temporalContext: m.temporal_context ?? null,
 			// Thread provenance: links memory to the conversation it was distilled from.
-			// CLI returns `source_thread`, API metadata returns `source_thread_id`.
+			// CLI returns `source_thread` (string), API returns `source_thread: {id, title}` (object).
 			sourceThreadId:
-				m.source_thread ??
+				(typeof m.source_thread === "object" && m.source_thread?.id
+					? String(m.source_thread.id)
+					: typeof m.source_thread === "string" ? m.source_thread : null) ??
 				m.source_thread_id ??
 				m.metadata?.source_thread_id ??
 				null,

package/src/config.js

@@ -21,6 +21,11 @@ const ALLOWED_KEYS = new Set([
 	"maxContextResults",
 	"recallMinScore",
 	"maxThreadMessageChars",
+	"captureExclude",
+	"captureSkipMarker",
+	"corpusSupplement",
+	"corpusMaxResults",
+	"corpusMinScore",
 	"apiUrl",
 	"apiKey",
 	// Legacy aliases — accepted but not advertised
@@ -195,6 +200,9 @@ function firstDefined(...options) {
  *   NMEM_MAX_CONTEXT_RESULTS   — integer (1-20)
  *   NMEM_RECALL_MIN_SCORE      — integer (0-100)
  *   NMEM_MAX_THREAD_MESSAGE_CHARS — integer (200-20000)
+ *   NMEM_CORPUS_SUPPLEMENT      — true/1/yes to register as MemoryCorpusSupplement
+ *   NMEM_CORPUS_MAX_RESULTS    — integer (1-20)
+ *   NMEM_CORPUS_MIN_SCORE      — integer (0-100)
  *   NMEM_API_URL               — remote server URL
  *   NMEM_API_KEY               — API key (never logged)
  */
@@ -343,6 +351,86 @@ export function parseConfig(raw, logger) {
 	const apiKey = ak.value;
 	_sources.apiKey = ak.source;
 
+	// --- corpusSupplement: file > pluginConfig > env > default ---
+	const cs = firstDefined(
+		{ value: pickBool(resolvedFile, "corpusSupplement"), source: "file" },
+		{
+			value: pickBool(resolvedPlugin, "corpusSupplement"),
+			source: "pluginConfig",
+		},
+		{
+			value: envBool("NMEM_CORPUS_SUPPLEMENT"),
+			source: "env",
+		},
+		{ value: false, source: "default" },
+	);
+	const corpusSupplement = cs.value;
+	_sources.corpusSupplement = cs.source;
+
+	// --- corpusMaxResults: file > pluginConfig > env > default ---
+	const cmr = firstDefined(
+		{ value: pickNum(resolvedFile, "corpusMaxResults"), source: "file" },
+		{
+			value: pickNum(resolvedPlugin, "corpusMaxResults"),
+			source: "pluginConfig",
+		},
+		{ value: envInt("NMEM_CORPUS_MAX_RESULTS"), source: "env" },
+		{ value: 5, source: "default" },
+	);
+	const corpusMaxResults = Math.min(20, Math.max(1, Math.trunc(cmr.value)));
+	_sources.corpusMaxResults = cmr.source;
+
+	// --- corpusMinScore: file > pluginConfig > env > default ---
+	const cmsEnv = envInt("NMEM_CORPUS_MIN_SCORE");
+	const cms = firstDefined(
+		{ value: pickNum(resolvedFile, "corpusMinScore"), source: "file" },
+		{
+			value: pickNum(resolvedPlugin, "corpusMinScore"),
+			source: "pluginConfig",
+		},
+		{ value: cmsEnv, source: "env" },
+		{ value: 0, source: "default" },
+	);
+	const corpusMinScore = Math.min(100, Math.max(0, Math.trunc(cms.value)));
+	_sources.corpusMinScore = cms.source;
+
+	// --- captureExclude: file > pluginConfig > default ---
+	const captureExclude = (() => {
+		const fromFile = Array.isArray(resolvedFile.captureExclude)
+			? resolvedFile.captureExclude
+			: null;
+		const fromPlugin = Array.isArray(resolvedPlugin.captureExclude)
+			? resolvedPlugin.captureExclude
+			: null;
+		_sources.captureExclude = fromFile
+			? "file"
+			: fromPlugin
+				? "pluginConfig"
+				: "default";
+		const entries = fromFile ?? fromPlugin ?? [];
+		return entries
+			.filter((v) => typeof v === "string" && v.trim())
+			.map((v) => v.trim());
+	})();
+
+	// --- captureSkipMarker: file > pluginConfig > default ---
+	const captureSkipMarker = (() => {
+		const fromFile =
+			typeof resolvedFile.captureSkipMarker === "string"
+				? resolvedFile.captureSkipMarker.trim()
+				: undefined;
+		const fromPlugin =
+			typeof resolvedPlugin.captureSkipMarker === "string"
+				? resolvedPlugin.captureSkipMarker.trim()
+				: undefined;
+		_sources.captureSkipMarker = fromFile
+			? "file"
+			: fromPlugin
+				? "pluginConfig"
+				: "default";
+		return fromFile || fromPlugin || "#nmem-skip";
+	})();
+
 	return {
 		sessionContext,
 		sessionDigest,
@@ -350,6 +438,11 @@ export function parseConfig(raw, logger) {
 		maxContextResults,
 		recallMinScore,
 		maxThreadMessageChars,
+		captureExclude,
+		captureSkipMarker,
+		corpusSupplement,
+		corpusMaxResults,
+		corpusMinScore,
 		apiUrl,
 		apiKey,
 		_sources,

package/src/context-engine.js

@@ -22,7 +22,13 @@
 
 import { ceState } from "./ce-state.js";
 import { BASE_GUIDANCE, SESSION_CONTEXT_GUIDANCE } from "./hooks/behavioral.js";
-import { appendOrCreateThread, triageAndDistill } from "./hooks/capture.js";
+import {
+	appendOrCreateThread,
+	hasSkipMarker,
+	isCronCaptureSessionKey,
+	matchesExcludePattern,
+	triageAndDistill,
+} from "./hooks/capture.js";
 import {
 	MAX_QUERY_LENGTH,
 	SHORT_QUERY_THRESHOLD,
@@ -165,7 +171,7 @@ export function createNowledgeMemContextEngineFactory(client, cfg, logger) {
 			info: {
 				id: "nowledge-mem",
 				name: "Nowledge Mem",
-				version: "0.7.0",
+				version: "0.8.0",
 				ownsCompaction: false,
 			},
 
@@ -230,7 +236,8 @@ export function createNowledgeMemContextEngineFactory(client, cfg, logger) {
 				}
 
 				// 3. Recalled memories (when sessionContext enabled)
-				if (cfg.sessionContext) {
+				// Skipped when corpus supplement handles search-based recall via memory-core.
+				if (cfg.sessionContext && !cfg.corpusSupplement) {
 					const query = buildAssembleSearchQuery(prompt, messages);
 					if (query) {
 						try {
@@ -342,8 +349,28 @@ export function createNowledgeMemContextEngineFactory(client, cfg, logger) {
 			}) {
 				if (isHeartbeat) return;
 
+				// Normalize sessionKey consistently with hook handlers
+				const normalizedKey = String(sessionKey || sessionId || "");
+
+				if (isCronCaptureSessionKey(normalizedKey)) {
+					logger.debug?.(`ce: skipped cron session ${normalizedKey}`);
+					return;
+				}
+
+				// Capture exclusion: pattern-based and marker-based filters
+				if (matchesExcludePattern(normalizedKey, cfg.captureExclude)) {
+					logger.debug?.(`ce: skipped excluded session ${normalizedKey}`);
+					return;
+				}
+				if (hasSkipMarker(messages, cfg.captureSkipMarker)) {
+					logger.debug?.(
+						`ce: skipped session with skip marker ${normalizedKey}`,
+					);
+					return;
+				}
+
 				const event = { messages, sessionFile };
-				const ctx = { sessionId, sessionKey };
+				const ctx = { sessionId, sessionKey: normalizedKey };
 
 				// 1. Always capture thread (idempotent, deduped)
 				const captureResult = await appendOrCreateThread({

package/src/corpus-supplement.js

@@ -0,0 +1,167 @@
+/**
+ * MemoryCorpusSupplement implementation for OpenClaw's memory-core recall pipeline.
+ *
+ * When registered, Nowledge Mem's knowledge graph becomes searchable through
+ * memory-core's native `memory_search` tool and its dreaming promotion pipeline.
+ * This means memories stored in Nowledge Mem participate in OpenClaw's recall
+ * scoring, temporal decay, and short-term-to-long-term promotion — without the
+ * user needing to explicitly call Nowledge Mem tools.
+ *
+ * Enable via config: `corpusSupplement: true`
+ *
+ * Designed to coexist with the plugin's own tools and hooks:
+ * - Working Memory injection: still handled by the recall hook / CE (only we know about WM)
+ * - Search-based recall: handled by this supplement when active, by hooks/CE when not
+ *
+ * Error handling: both search() and get() catch all errors and return [] / null.
+ * Supplement failures must never break OpenClaw's recall pipeline.
+ */
+
+/** Max snippet length in search results (matches memory-search.js truncation). */
+const SNIPPET_MAX_CHARS = 700;
+
+/**
+ * Parse a memory ID from a path or bare ID string.
+ * Handles `nowledgemem://memory/<id>` URIs and bare alphanumeric IDs.
+ */
+function parseMemoryId(pathValue) {
+	const value = String(pathValue || "").trim();
+	if (!value) return null;
+
+	const fromDeeplink = value.match(
+		/^nowledgemem:\/\/memory\/([a-zA-Z0-9_-]+)$/u,
+	);
+	if (fromDeeplink) return fromDeeplink[1];
+
+	if (/^[a-zA-Z0-9_-]{8,}$/u.test(value)) {
+		return value;
+	}
+
+	return null;
+}
+
+/**
+ * Slice lines from text content with 1-based line indexing.
+ */
+function sliceLines(text, from, lines) {
+	const allLines = String(text || "").split(/\r?\n/u);
+	const start = Math.max(1, Math.trunc(Number(from) || 1));
+	const maxLines = Math.max(1, Math.trunc(Number(lines) || allLines.length));
+	const startIdx = start - 1;
+	const endIdx = Math.min(allLines.length, startIdx + maxLines);
+	const selected = allLines.slice(startIdx, endIdx);
+	return {
+		text: selected.join("\n"),
+		startLine: start,
+		endLine: Math.max(start, start + selected.length - 1),
+		totalLines: allLines.length,
+	};
+}
+
+/**
+ * Create a MemoryCorpusSupplement backed by the Nowledge Mem knowledge graph.
+ *
+ * @param {import('./client.js').NowledgeMemClient} client
+ * @param {object} cfg  Parsed plugin config (corpusMaxResults, corpusMinScore)
+ * @param {object} logger
+ * @returns {{ search: Function, get: Function }}
+ */
+export function createNowledgeMemCorpusSupplement(client, cfg, logger) {
+	const maxResults = cfg.corpusMaxResults ?? 5;
+	const minScore = (cfg.corpusMinScore ?? 0) / 100; // config is 0-100, API is 0-1
+
+	return {
+		/**
+		 * Search Nowledge Mem's knowledge graph for memories matching the query.
+		 * Called by memory-core's recall pipeline on every turn.
+		 */
+		async search({ query, maxResults: requestedMax }) {
+			try {
+				const limit = Math.min(20, Math.max(1, requestedMax ?? maxResults));
+				const results = await client.search(query, limit);
+
+				const filtered =
+					minScore > 0
+						? results.filter((r) => (r.score ?? 0) >= minScore)
+						: results;
+
+				return filtered.map((m) => {
+					const snippet = String(m.content || "").slice(0, SNIPPET_MAX_CHARS);
+					const lineCount = Math.max(1, snippet.split(/\r?\n/u).length);
+					const result = {
+						corpus: "nowledge-mem",
+						path: `nowledgemem://memory/${m.id}`,
+						score: Number(m.score ?? 0),
+						snippet,
+						title: m.title || undefined,
+						kind: m.labels?.[0] || undefined,
+						id: m.id,
+						startLine: 1,
+						endLine: lineCount,
+						provenanceLabel: "Nowledge Mem",
+						source: "nowledge-mem",
+						sourceType: "knowledge-graph",
+					};
+					return result;
+				});
+			} catch (err) {
+				logger.warn?.(
+					`corpus-supplement: search failed: ${err instanceof Error ? err.message : err}`,
+				);
+				return [];
+			}
+		},
+
+		/**
+		 * Retrieve a specific memory by path or ID.
+		 * Called when memory-core's agent requests full content for a search result.
+		 */
+		async get({ lookup, fromLine, lineCount }) {
+			try {
+				// Handle Working Memory alias
+				const lowerLookup = String(lookup || "")
+					.trim()
+					.toLowerCase();
+				if (lowerLookup === "memory.md" || lowerLookup === "memory") {
+					const wm = await client.readWorkingMemory();
+					if (!wm.available) return null;
+					const slice = sliceLines(wm.content, fromLine, lineCount);
+					return {
+						corpus: "nowledge-mem",
+						path: "nowledgemem://working-memory",
+						title: "Working Memory",
+						content: slice.text,
+						fromLine: slice.startLine,
+						lineCount: slice.endLine - slice.startLine + 1,
+						provenanceLabel: "Nowledge Mem",
+						sourceType: "working-memory",
+					};
+				}
+
+				const memoryId = parseMemoryId(lookup);
+				if (!memoryId) return null;
+
+				const memory = await client.getMemory(memoryId);
+				if (!memory) return null;
+				const slice = sliceLines(memory.content ?? "", fromLine, lineCount);
+
+				return {
+					corpus: "nowledge-mem",
+					path: `nowledgemem://memory/${memoryId}`,
+					title: memory.title || undefined,
+					content: slice.text,
+					fromLine: slice.startLine,
+					lineCount: slice.endLine - slice.startLine + 1,
+					id: memoryId,
+					provenanceLabel: "Nowledge Mem",
+					sourceType: "knowledge-graph",
+				};
+			} catch (err) {
+				logger.warn?.(
+					`corpus-supplement: get failed: ${err instanceof Error ? err.message : err}`,
+				);
+				return null;
+			}
+		},
+	};
+}

package/src/hooks/capture.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
+import { isCronSessionKey } from "openclaw/plugin-sdk/routing";
 import { ceState } from "../ce-state.js";
 
 export const DEFAULT_MAX_MESSAGE_CHARS = 800;
@@ -40,6 +41,82 @@ function _setSyncedMessageCount(threadId, count) {
 	}
 }
 
+// ---------------------------------------------------------------------------
+// Capture exclusion filters
+// ---------------------------------------------------------------------------
+
+/**
+ * Compile a glob pattern (where `*` matches within a colon-delimited segment)
+ * into a RegExp. Results are cached since patterns are immutable after parse.
+ */
+const _compiledPatterns = new Map();
+function _compileGlob(pattern) {
+	const key = String(pattern).toLowerCase();
+	let re = _compiledPatterns.get(key);
+	if (!re) {
+		re = new RegExp(
+			"^" +
+				key
+					.replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+					.replace(/\*/g, "[^:]*") +
+				"$",
+		);
+		_compiledPatterns.set(key, re);
+	}
+	return re;
+}
+
+/**
+ * Test whether a session key matches any exclusion glob pattern.
+ * Glob `*` matches within a colon-delimited segment (not across colons).
+ * Example: "agent:*:cron:*" matches "agent:main:cron:abc123"
+ *
+ * Exported for reuse by Context Engine and other capture paths.
+ */
+export function matchesExcludePattern(sessionKey, patterns) {
+	if (!Array.isArray(patterns) || patterns.length === 0) return false;
+	const key = String(sessionKey || "").toLowerCase();
+	return patterns.some((pattern) => _compileGlob(pattern).test(key));
+}
+
+/**
+ * Whether automatic thread capture should skip this OpenClaw session.
+ *
+ * - Agent-scoped cron / isolated-agent keys are classified by
+ *   `isCronSessionKey` from `openclaw/plugin-sdk/routing` (same implementation
+ *   the gateway uses). Requires OpenClaw >=2026.3.22.
+ * - Bare `cron:*` keys are still excluded: some internal paths (e.g. delivery /
+ *   failure bookkeeping) use that shape without the `agent:` prefix, and
+ *   `isCronSessionKey` only parses agent-scoped keys.
+ */
+export function isCronCaptureSessionKey(sessionKey) {
+	const raw = String(sessionKey || "")
+		.trim()
+		.toLowerCase();
+	if (!raw) return false;
+	if (raw.startsWith("cron:")) return true;
+	return isCronSessionKey(raw);
+}
+
+/**
+ * Check if any message contains the skip marker text.
+ * Scans both raw message content and nested message objects.
+ *
+ * Exported for reuse by Context Engine and other capture paths.
+ */
+export function hasSkipMarker(messages, marker) {
+	if (!marker || typeof marker !== "string" || !Array.isArray(messages)) return false;
+	const markerLc = marker.toLowerCase();
+	return messages.some((msg) => {
+		const text = extractText(msg?.content ?? msg?.message?.content);
+		return text.toLowerCase().includes(markerLc);
+	});
+}
+
+// ---------------------------------------------------------------------------
+// Message normalization utilities
+// ---------------------------------------------------------------------------
+
 export function truncate(text, max = DEFAULT_MAX_MESSAGE_CHARS) {
 	const str = String(text || "").trim();
 	if (!str) return "";
@@ -197,8 +274,9 @@ export async function appendOrCreateThread({
 	ctx,
 	reason,
 	maxMessageChars = DEFAULT_MAX_MESSAGE_CHARS,
+	resolvedMessages,
 }) {
-	const rawMessages = await resolveHookMessages(event);
+	const rawMessages = resolvedMessages ?? (await resolveHookMessages(event));
 	if (!Array.isArray(rawMessages) || rawMessages.length === 0) return;
 
 	const threadId = buildStableThreadId(event, ctx);
@@ -413,6 +491,27 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
 		if (!event?.success) return;
 		if (ctx?.trigger === "heartbeat") return;
 
+		const sessionKey = String(ctx?.sessionKey || ctx?.sessionId || "");
+		if (isCronCaptureSessionKey(sessionKey)) {
+			logger.debug?.(`capture: skipped cron session ${sessionKey}`);
+			return;
+		}
+
+		// Pattern-based exclusion (e.g. subagent sessions, custom jobs)
+		if (matchesExcludePattern(sessionKey, cfg.captureExclude)) {
+			logger.debug?.(`capture: skipped excluded session ${sessionKey}`);
+			return;
+		}
+
+		// Layer 2: marker-based exclusion (user typed #nmem-skip in conversation)
+		const resolvedMessages = await resolveHookMessages(event);
+		if (hasSkipMarker(resolvedMessages, cfg.captureSkipMarker)) {
+			logger.debug?.(
+				`capture: skipped session with skip marker ${sessionKey}`,
+			);
+			return;
+		}
+
 		const captureResult = await appendOrCreateThread({
 			client,
 			logger,
@@ -420,6 +519,7 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
 			ctx,
 			reason: "agent_end",
 			maxMessageChars: cfg.maxThreadMessageChars,
+			resolvedMessages,
 		});
 
 		await triageAndDistill({ client, cfg, logger, captureResult, ctx });
@@ -435,10 +535,31 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
  *
  * Heartbeat sessions are skipped (same rationale as agent_end).
  */
-export function buildBeforeResetCaptureHandler(client, _cfg, logger) {
+export function buildBeforeResetCaptureHandler(client, cfg, logger) {
 	return async (event, ctx) => {
 		if (ceState.active) return;
 		if (ctx?.trigger === "heartbeat") return;
+
+		const sessionKey = String(ctx?.sessionKey || ctx?.sessionId || "");
+		if (isCronCaptureSessionKey(sessionKey)) {
+			logger.debug?.(`capture: skipped cron session ${sessionKey}`);
+			return;
+		}
+
+		if (matchesExcludePattern(sessionKey, cfg.captureExclude)) {
+			logger.debug?.(`capture: skipped excluded session ${sessionKey}`);
+			return;
+		}
+
+		// Layer 2: marker-based exclusion
+		const resolvedMessages = await resolveHookMessages(event);
+		if (hasSkipMarker(resolvedMessages, cfg.captureSkipMarker)) {
+			logger.debug?.(
+				`capture: skipped session with skip marker ${sessionKey}`,
+			);
+			return;
+		}
+
 		const reason = typeof event?.reason === "string" ? event.reason : undefined;
 		await appendOrCreateThread({
 			client,
@@ -446,7 +567,8 @@ export function buildBeforeResetCaptureHandler(client, _cfg, logger) {
 			event,
 			ctx,
 			reason,
-			maxMessageChars: _cfg?.maxThreadMessageChars,
+			maxMessageChars: cfg.maxThreadMessageChars,
+			resolvedMessages,
 		});
 	};
 }

package/src/hooks/recall.js

@@ -180,15 +180,18 @@ export function buildRecalledKnowledgeBlock(
 export function buildRecallHandler(client, cfg, logger) {
 	const minScore = (cfg.recallMinScore ?? 0) / 100; // config is 0-100, API is 0-1
 
+	// When corpus supplement is active, memory-core's recall pipeline searches
+	// Nowledge Mem via the supplement. We still inject Working Memory (only we
+	// know about WM), but skip our own search-based recall to avoid duplicates.
+	const skipSearchRecall = cfg.corpusSupplement;
+
 	return async (event) => {
 		if (ceState.active) return;
 
-		const searchQuery = buildSearchQuery(event);
-		if (!searchQuery) return;
-
 		const sections = [];
 
-		// 1. Working Memory — daily context, not a static profile
+		// 1. Working Memory — daily context, not a static profile.
+		// Always injected regardless of search query (WM is independent of user message).
 		try {
 			const wm = await client.readWorkingMemory();
 			if (wm.available) {
@@ -200,22 +203,26 @@ export function buildRecallHandler(client, cfg, logger) {
 			logger.error(`recall: working memory read failed: ${err}`);
 		}
 
-		// 2. Relevant memories — enriched with scoring signals and labels
-		try {
-			const results = await client.searchRich(
-				searchQuery,
-				cfg.maxContextResults,
-			);
-			// Filter by minimum score if configured
-			const filtered =
-				minScore > 0
-					? results.filter((r) => (r.score ?? 0) >= minScore)
-					: results;
-			if (filtered.length > 0) {
-				sections.push(buildRecalledKnowledgeBlock(filtered));
+		// 2. Relevant memories — enriched with scoring signals and labels.
+		// Skipped when corpus supplement handles search-based recall via memory-core.
+		const searchQuery = buildSearchQuery(event);
+		if (!skipSearchRecall && searchQuery) {
+			try {
+				const results = await client.searchRich(
+					searchQuery,
+					cfg.maxContextResults,
+				);
+				// Filter by minimum score if configured
+				const filtered =
+					minScore > 0
+						? results.filter((r) => (r.score ?? 0) >= minScore)
+						: results;
+				if (filtered.length > 0) {
+					sections.push(buildRecalledKnowledgeBlock(filtered));
+				}
+			} catch (err) {
+				logger.error(`recall: search failed: ${err}`);
 			}
-		} catch (err) {
-			logger.error(`recall: search failed: ${err}`);
 		}
 
 		if (sections.length === 0) return;

package/src/index.js

@@ -7,6 +7,7 @@ import {
 } from "./commands/slash.js";
 import { isDefaultApiUrl, parseConfig } from "./config.js";
 import { createNowledgeMemContextEngineFactory } from "./context-engine.js";
+import { createNowledgeMemCorpusSupplement } from "./corpus-supplement.js";
 import { buildBehavioralHook } from "./hooks/behavioral.js";
 import {
 	buildAgentEndCaptureHandler,
@@ -54,8 +55,14 @@ export default {
 		api.registerTool(createThreadSearchTool(client, logger));
 		api.registerTool(createThreadFetchTool(client, logger));
 
-		// Diagnostics
-		api.registerTool(createStatusTool(client, logger, cfg));
+		// Diagnostics — pass runtime config so the status tool can detect:
+		//   - plugins.allow missing or not including this plugin
+		//   - memory slot pointing elsewhere (e.g. memory-core)
+		const memorySlot = api.config?.plugins?.slots?.memory;
+		const pluginsAllow = api.config?.plugins?.allow;
+		api.registerTool(
+			createStatusTool(client, logger, cfg, { memorySlot, pluginsAllow }),
+		);
 
 		// --- Context Engine registration ---
 		// When the user sets `plugins.slots.contextEngine: "nowledge-mem"`,
@@ -74,6 +81,27 @@ export default {
 			);
 		}
 
+		// --- Corpus Supplement (when memory-core is the memory slot) ---
+		// Makes Nowledge Mem's knowledge graph searchable through memory-core's
+		// recall pipeline and dreaming promotion. Memories participate in
+		// temporal decay scoring and short-term-to-long-term promotion.
+		if (cfg.corpusSupplement) {
+			try {
+				api.registerMemoryCorpusSupplement(
+					createNowledgeMemCorpusSupplement(client, cfg, logger),
+				);
+				logger.info(
+					"nowledge-mem: registered as MemoryCorpusSupplement for memory-core recall",
+				);
+			} catch (err) {
+				// OpenClaw < corpus supplement support — fall back to normal recall
+				cfg.corpusSupplement = false;
+				logger.info?.(
+					`nowledge-mem: corpus supplement unavailable, falling back to normal recall (${err})`,
+				);
+			}
+		}
+
 		// --- Hooks (fallback when CE is not active) ---
 		// Each hook checks ceState.active and returns early when the CE handles
 		// the same lifecycle through assemble/afterTurn.
@@ -114,7 +142,7 @@ export default {
 
 		const remoteMode = !isDefaultApiUrl(cfg.apiUrl);
 		logger.info(
-			`nowledge-mem: initialized (context=${cfg.sessionContext}, digest=${cfg.sessionDigest}, mode=${remoteMode ? `remote → ${cfg.apiUrl}` : "local"})`,
+			`nowledge-mem: initialized (context=${cfg.sessionContext}, digest=${cfg.sessionDigest}, corpus=${cfg.corpusSupplement}, mode=${remoteMode ? `remote → ${cfg.apiUrl}` : "local"})`,
 		);
 	},
 };

package/src/spawn-env.js

@@ -7,8 +7,8 @@ const LOCAL_API_URL = "http://127.0.0.1:14242";
  */
 export function buildNmemSpawnEnv({ apiUrl, apiKey } = {}) {
 	const env = { ...process.env };
-	env.NMEM_API_URL = undefined;
-	env.NMEM_API_KEY = undefined;
+	delete env.NMEM_API_URL;
+	delete env.NMEM_API_KEY;
 	if (apiUrl && apiUrl !== LOCAL_API_URL) {
 		env.NMEM_API_URL = apiUrl;
 	}

package/src/tools/memory-get.js

@@ -135,9 +135,13 @@ export function createMemoryGetTool(client, logger) {
 					safeParams.lines,
 				);
 
-				// Thread provenance: link to the source conversation
+				// Thread provenance: link to the source conversation.
+				// API returns source_thread as {id, title} object; CLI returns a string.
+				const rawSt = memory.source_thread;
 				const sourceThreadId =
-					memory.source_thread ??
+					(typeof rawSt === "object" && rawSt?.id
+						? String(rawSt.id)
+						: typeof rawSt === "string" ? rawSt : null) ??
 					memory.source_thread_id ??
 					memory.metadata?.source_thread_id ??
 					null;

package/src/tools/status.js

@@ -7,7 +7,7 @@
  */
 import { isDefaultApiUrl } from "../config.js";
 
-export function createStatusTool(client, _logger, cfg) {
+export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 	return {
 		name: "nowledge_mem_status",
 		description:
@@ -23,6 +23,73 @@ export function createStatusTool(client, _logger, cfg) {
 			const details = {};
 			const sources = cfg._sources || {};
 
+			// 0a. Plugin trust check — detect missing plugins.allow
+			const pluginsAllow = runtimeInfo.pluginsAllow;
+			const pluginId = "openclaw-nowledge-mem";
+			details.pluginsAllow = !Array.isArray(pluginsAllow)
+				? "(not set)"
+				: pluginsAllow.includes(pluginId)
+					? "listed"
+					: "set but plugin not included";
+
+			if (
+				Array.isArray(pluginsAllow) &&
+				pluginsAllow.length > 0 &&
+				!pluginsAllow.includes(pluginId)
+			) {
+				lines.push(
+					`⚠ plugins.allow is set but does not include "${pluginId}".`,
+				);
+				lines.push(
+					"  The plugin will be BLOCKED from loading unless it holds the memory slot or is explicitly enabled.",
+				);
+				lines.push(
+					`  Fix: add "${pluginId}" to plugins.allow in your OpenClaw config.`,
+				);
+				lines.push("");
+			} else if (!Array.isArray(pluginsAllow) || pluginsAllow.length === 0) {
+				lines.push(
+					"Plugin trust: plugins.allow not set (plugin loads via entries.enabled)",
+				);
+				lines.push(
+					`  Tip: set plugins.allow to ["${pluginId}"] to pin trust explicitly.`,
+				);
+				lines.push("");
+			} else {
+				lines.push(`Plugin trust: ${pluginId} (allowlisted)`);
+			}
+
+			// 0b. Memory slot check — show current mode and options
+			const memorySlot = runtimeInfo.memorySlot;
+			details.memorySlot = memorySlot ?? "(unknown)";
+			if (memorySlot && memorySlot !== "openclaw-nowledge-mem") {
+				const corpusOn = cfg.corpusSupplement === true;
+				if (corpusOn) {
+					lines.push(
+						`Memory slot: "${memorySlot}" + corpus supplement active`,
+					);
+					lines.push(
+						"  Nowledge Mem feeds into memory-core's recall and dreaming pipeline. All tools available.",
+					);
+				} else {
+					lines.push(
+						`ℹ Memory slot: "${memorySlot}"`,
+					);
+					lines.push(
+						"  Two options:",
+					);
+					lines.push(
+						'  - Full mode: set plugins.slots.memory to "openclaw-nowledge-mem" for the complete tool surface',
+					);
+					lines.push(
+						"  - Dual mode: set corpusSupplement: true to feed your cross-tool knowledge into memory-core's recall and dreaming",
+					);
+				}
+				lines.push("");
+			} else if (memorySlot === "openclaw-nowledge-mem") {
+				lines.push("Memory slot: openclaw-nowledge-mem (active)");
+			}
+
 			// 1. Mode + connection target
 			const remote = !isDefaultApiUrl(cfg.apiUrl);
 			const mode = remote ? "remote" : "local";