@nowledge/openclaw-nowledge-mem 0.7.3 → 0.8.1

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to the Nowledge Mem OpenClaw plugin will be documented in this file.
 
+## [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

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:
@@ -153,6 +176,9 @@ Credentials (apiUrl/apiKey): also reads `~/.nowledge-mem/config.json` (shared wi
 | `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
 ```

package/openclaw.plugin.json

@@ -1,8 +1,10 @@
 {
 	"id": "openclaw-nowledge-mem",
-	"version": "0.7.3",
+	"version": "0.8.1",
 	"kind": "memory",
-	"skills": ["skills/memory-guide"],
+	"skills": [
+		"skills/memory-guide"
+	],
 	"uiHints": {
 		"sessionContext": {
 			"label": "Session context injection",
@@ -30,11 +32,23 @@
 		},
 		"captureExclude": {
 			"label": "Exclude session patterns",
-			"help": "Session key glob patterns to skip during auto-capture. Use * to match within a colon-segment. Example: agent:*:cron:*"
+			"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 — use captureExclude patterns for persistent filtering."
+			"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)",
@@ -89,14 +103,35 @@
 			},
 			"captureExclude": {
 				"type": "array",
-				"items": { "type": "string" },
+				"items": {
+					"type": "string"
+				},
 				"default": [],
-				"description": "Session key glob patterns to exclude from auto-capture. Glob * matches within a colon-delimited segment. Example: agent:*:cron:* excludes all cron job sessions."
+				"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 — use captureExclude for persistent filtering."
+				"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",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nowledge/openclaw-nowledge-mem",
-	"version": "0.7.3",
+	"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

@@ -23,6 +23,9 @@ const ALLOWED_KEYS = new Set([
 	"maxThreadMessageChars",
 	"captureExclude",
 	"captureSkipMarker",
+	"corpusSupplement",
+	"corpusMaxResults",
+	"corpusMinScore",
 	"apiUrl",
 	"apiKey",
 	// Legacy aliases — accepted but not advertised
@@ -197,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)
  */
@@ -345,6 +351,49 @@ 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)
@@ -391,6 +440,9 @@ export function parseConfig(raw, logger) {
 		maxThreadMessageChars,
 		captureExclude,
 		captureSkipMarker,
+		corpusSupplement,
+		corpusMaxResults,
+		corpusMinScore,
 		apiUrl,
 		apiKey,
 		_sources,

package/src/context-engine.js

@@ -25,6 +25,7 @@ import { BASE_GUIDANCE, SESSION_CONTEXT_GUIDANCE } from "./hooks/behavioral.js";
 import {
 	appendOrCreateThread,
 	hasSkipMarker,
+	isCronCaptureSessionKey,
 	matchesExcludePattern,
 	triageAndDistill,
 } from "./hooks/capture.js";
@@ -170,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,
 			},
 
@@ -235,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 {
@@ -350,6 +352,11 @@ export function createNowledgeMemContextEngineFactory(client, cfg, logger) {
 				// 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}`);

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;
@@ -78,6 +79,25 @@ export function matchesExcludePattern(sessionKey, patterns) {
 	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.
@@ -471,8 +491,13 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
 		if (!event?.success) return;
 		if (ctx?.trigger === "heartbeat") return;
 
-		// Layer 1: pattern-based exclusion (e.g. cron jobs, subagent sessions)
 		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;
@@ -515,8 +540,12 @@ export function buildBeforeResetCaptureHandler(client, cfg, logger) {
 		if (ceState.active) return;
 		if (ctx?.trigger === "heartbeat") return;
 
-		// Layer 1: pattern-based exclusion
 		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;

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,
@@ -80,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.
@@ -120,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

@@ -59,19 +59,32 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 				lines.push(`Plugin trust: ${pluginId} (allowlisted)`);
 			}
 
-			// 0b. Memory slot check — detect misconfiguration early
+			// 0b. Memory slot check — show current mode and options
 			const memorySlot = runtimeInfo.memorySlot;
 			details.memorySlot = memorySlot ?? "(unknown)";
 			if (memorySlot && memorySlot !== "openclaw-nowledge-mem") {
-				lines.push(
-					`⚠ Memory slot: "${memorySlot}" — Nowledge Mem is NOT the active memory plugin.`,
-				);
-				lines.push(
-					"  Only memory_search and memory_get will work. Other tools (save, connections, timeline, etc.) are inactive.",
-				);
-				lines.push(
-					'  Fix: run "openclaw plugins install @nowledge/openclaw-nowledge-mem" or set plugins.slots.memory to "openclaw-nowledge-mem" in your config.',
-				);
+				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)");