@nowledge/openclaw-nowledge-mem 0.7.3 → 0.8.3

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 All notable changes to the Nowledge Mem OpenClaw plugin will be documented in this file.
 
+## [0.8.3] - 2026-04-08
+
+### Added
+
+- Added a release validator and ClawHub publish runbook so package metadata, manifest defaults, and publish-time expectations can be checked before submission.
+
+### Changed
+
+- Added the external code-plugin metadata ClawHub expects in `package.json` and aligned the manifest-facing package description for official catalog review.
+- Synced the checked-in `package-lock.json` package version with the actual plugin version so pack and publish surfaces stay coherent.
+- Tightened the release validator so it now catches changelog drift, `openclaw.release` flag drift, unreadable required files, and config-schema contract changes before a ClawHub publish.
+- Updated install guidance to use ClawHub as the primary path while keeping bare package names documented as a resolver fallback.
+
+## [0.8.2] - 2026-04-08
+
+### Changed
+
+- **Assertive behavioral guidance replaces conditional phrasing.** The per-turn system prompt injection now uses "Search proactively... Do not wait to be asked" and "Save autonomously... Do not wait to be asked" instead of the previous "Before answering questions about prior work... search." This directly addresses reports of GPT 5.4 and Kimi K2.5 not proactively searching memories. Also trimmed redundant lines (signal examples, output-format description) to keep the injection tight (~60 tokens), restoring the "(not file paths)" hint.
+
+## [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,16 +9,30 @@ 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
 
 ```bash
-openclaw plugins install @nowledge/openclaw-nowledge-mem
+openclaw plugins install clawhub:@nowledge/openclaw-nowledge-mem
 ```
 
 OpenClaw's installer writes the install record, enables the plugin, and switches the `memory` slot to `openclaw-nowledge-mem`. Restart OpenClaw after install to load it.
 
+If you prefer the default resolver path, bare package names also work because OpenClaw resolves external plugins from ClawHub first and then falls back to npm:
+
+```bash
+openclaw plugins install @nowledge/openclaw-nowledge-mem
+```
+
+If you need a pinned local checkout for validation or development, use local linking:
+
+```bash
+git clone https://github.com/nowledge-co/community.git
+cd community/nowledge-mem-openclaw-plugin
+openclaw plugins install --link .
+```
+
 ### Agent-assisted setup
 
 If another AI agent is helping you install this plugin, point it at the bundled [SKILL.md](./SKILL.md).
@@ -187,6 +201,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 +400,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 +430,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
 ```
@@ -440,7 +474,7 @@ If you also use linked or workspace copies, review `plugins.load.paths` before r
 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
+openclaw plugins install clawhub:@nowledge/openclaw-nowledge-mem
 ```
 
 Or set the slot manually in `~/.openclaw/openclaw.json`:

package/SKILL.md

@@ -102,20 +102,13 @@ Success means the backend responds correctly through `nmem`. Do not skip this st
 Default install:
 
 ```bash
-openclaw plugins install @nowledge/openclaw-nowledge-mem
+openclaw plugins install clawhub:@nowledge/openclaw-nowledge-mem
 ```
 
-If the user is on mainland China or npmjs is unusually slow, prefer a one-shot mirror override instead of changing global npm config:
+Alternatively, if the user is installing from OpenClaw's default registry rather than ClawHub, this also works:
 
 ```bash
-NPMJS_TIME="$(curl -o /dev/null -sS --connect-timeout 2 --max-time 6 -w '%{time_total}' https://registry.npmjs.org/@nowledge%2fopenclaw-nowledge-mem || echo timeout)"
-MIRROR_TIME="$(curl -o /dev/null -sS --connect-timeout 2 --max-time 6 -w '%{time_total}' https://registry.npmmirror.com/@nowledge%2fopenclaw-nowledge-mem || echo timeout)"
-
-if [ "$MIRROR_TIME" != "timeout" ] && { [ "$NPMJS_TIME" = "timeout" ] || awk "BEGIN { exit !($NPMJS_TIME > 2 && $MIRROR_TIME < $NPMJS_TIME) }"; }; then
-  NPM_CONFIG_REGISTRY=https://registry.npmmirror.com openclaw plugins install @nowledge/openclaw-nowledge-mem
-else
-  openclaw plugins install @nowledge/openclaw-nowledge-mem
-fi
+openclaw plugins install @nowledge/openclaw-nowledge-mem
 ```
 
 Important facts:
@@ -196,7 +189,7 @@ If only `memory_search` and `memory_get` tools are available (other 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.
+If missing, reinstall (`openclaw plugins install clawhub:@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.
 

package/openclaw.plugin.json

@@ -1,8 +1,12 @@
 {
 	"id": "openclaw-nowledge-mem",
-	"version": "0.7.3",
+	"name": "Nowledge Mem",
+	"description": "Cross-tool knowledge graph memory for OpenClaw with Working Memory, graph search, and session distillation.",
+	"version": "0.8.3",
 	"kind": "memory",
-	"skills": ["skills/memory-guide"],
+	"skills": [
+		"skills/memory-guide"
+	],
 	"uiHints": {
 		"sessionContext": {
 			"label": "Session context injection",
@@ -30,11 +34,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 +105,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,7 @@
 {
 	"name": "@nowledge/openclaw-nowledge-mem",
-	"version": "0.7.3",
+	"displayName": "Nowledge Mem for OpenClaw",
+	"version": "0.8.3",
 	"type": "module",
 	"description": "Nowledge Mem memory plugin for OpenClaw, local-first personal knowledge base",
 	"author": {
@@ -24,15 +25,30 @@
 		"openclaw.plugin.json"
 	],
 	"openclaw": {
-		"extensions": ["./src/index.js"]
+		"extensions": ["./src/index.js"],
+		"install": {
+			"npmSpec": "@nowledge/openclaw-nowledge-mem",
+			"minHostVersion": ">=2026.4.5"
+		},
+		"compat": {
+			"pluginApi": ">=2026.4.5"
+		},
+		"build": {
+			"openclawVersion": "2026.4.5"
+		},
+		"release": {
+			"publishToClawHub": true,
+			"publishToNpm": true
+		}
 	},
 	"main": "src/index.js",
 	"scripts": {
+		"validate": "node scripts/validate-plugin.mjs",
 		"lint": "biome check .",
 		"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/behavioral.js

@@ -20,11 +20,9 @@ import { ceState } from "../ce-state.js";
 export const BASE_GUIDANCE = [
 	"<nowledge-mem-guidance>",
 	"You have access to the user's personal knowledge graph (Nowledge Mem).",
-	"Before answering questions about prior work, decisions, dates, people, preferences, or plans:",
-	"search with memory_search using natural language queries (not file paths).",
-	"memory_search returns memories with scores, labels, and relevant past conversation snippets.",
+	"Search proactively with memory_search when past context would improve your answer. Do not wait to be asked. Use natural language queries, not file paths.",
 	"When results include a sourceThreadId, use nowledge_mem_thread_fetch for full conversation context.",
-	"When the conversation produces a decision, preference, plan, or learning, save it with nowledge_mem_save.",
+	"Save autonomously with nowledge_mem_save when the conversation produces a decision, preference, plan, procedure, or learning. Do not wait to be asked.",
 	"</nowledge-mem-guidance>",
 ].join("\n");
 
@@ -32,10 +30,9 @@ export const SESSION_CONTEXT_GUIDANCE = [
 	"<nowledge-mem-guidance>",
 	"You have access to the user's personal knowledge graph (Nowledge Mem).",
 	"Relevant memories and your Working Memory have already been injected into this prompt.",
-	"Use memory_search when you need something specific beyond what was auto-recalled (natural language queries, not file paths).",
-	"memory_search also returns relevant past conversation snippets alongside memories.",
+	"Use memory_search for specifics beyond what was auto-recalled, or when the user references prior work not covered above. Natural language queries, not file paths.",
 	"When results include a sourceThreadId, use nowledge_mem_thread_fetch for full conversation context.",
-	"When the conversation produces a decision, preference, plan, or learning, save it with nowledge_mem_save.",
+	"Save autonomously with nowledge_mem_save when the conversation produces a decision, preference, plan, procedure, or learning. Do not wait to be asked.",
 	"</nowledge-mem-guidance>",
 ].join("\n");
 

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)");