@nowledge/openclaw-nowledge-mem 0.8.18 → 0.8.21

package/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to the Nowledge Mem OpenClaw plugin will be documented in th
 
 ## Unreleased
 
+## [0.8.21] - 2026-04-29
+
+### Fixed
+
+- ClawHub installs no longer fail archive verification because `.clawhubignore` is now excluded from the published package manifest as well as the archive.
+
+## [0.8.20] - 2026-04-27
+
+### Fixed
+
+- ClawHub packages now exclude local `node_modules/`, preventing unpublished development artifacts from entering the security scan.
+- Remote HTTP requests no longer place API keys in URL query strings. The plugin keeps credentials in `Authorization` and `X-NMEM-API-Key` headers only.
+
+## [0.8.19] - 2026-04-21
+
+### Fixed
+
+- `corpusSupplement` fallback now preserves the user's configured intent when host registration is unavailable. The plugin keeps its own recall path active instead of silently mutating config state.
+- `nowledge_mem_status` now reports `corpusSupplement` as configured vs runtime-active, including fallback reason details when OpenClaw does not expose supplement registration in the current runtime.
+- Context Engine recall now follows **runtime supplement activation** instead of static config. If `corpusSupplement` is configured but host registration fails, prompt-time recall no longer gets skipped.
+- `nowledge_mem_status` no longer claims prompt-time fallback recall when `sessionContext=false`; status text now reflects the real runtime path.
+
 ## [0.8.18] - 2026-04-20
 
 ### Fixed

package/README.md

@@ -428,6 +428,14 @@ No config is required for a normal npm install. The defaults work for local mode
 
 To change settings, use the OpenClaw plugin settings UI. Changes take effect on restart.
 
+## Customize without editing the plugin
+
+OpenClaw does not currently have a separate user-owned instruction file in this integration contract.
+
+- Use the OpenClaw plugin settings UI for supported behavior changes such as `sessionContext`, digest controls, remote credentials, and space selection.
+- If you need additional behavioral guidance, customize OpenClaw's own prompt or agent configuration surface.
+- Do not patch the installed plugin source under the OpenClaw extensions directory.
+
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `sessionContext` | boolean | `false` | Inject Working Memory + relevant memories at prompt time |

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
 	"id": "openclaw-nowledge-mem",
 	"name": "Nowledge Mem",
 	"description": "Cross-tool knowledge graph memory for OpenClaw with Working Memory, graph search, and session distillation.",
-  "version": "0.8.18",
+  "version": "0.8.21",
 	"kind": ["memory", "context-engine"],
 	"skills": [
 		"skills/memory-guide"

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@nowledge/openclaw-nowledge-mem",
 	"displayName": "Nowledge Mem for OpenClaw",
-	"version": "0.8.18",
+	"version": "0.8.21",
 	"type": "module",
 	"description": "Nowledge Mem memory plugin for OpenClaw, local-first personal knowledge base",
 	"author": {

package/src/client.js

@@ -137,16 +137,15 @@ export class NowledgeMemClient {
 		const timer = setTimeout(() => controller.abort(), timeout);
 		const scopedPath = this._withSpaceQuery(path);
 		const scopedBody = this._withSpaceBody(body);
-		const url = `${this.getApiBaseUrl()}${scopedPath}`;
 		try {
-			const response = await fetch(url, {
+			const requestBody =
+				scopedBody === undefined ? undefined : JSON.stringify(scopedBody);
+			const response = await fetch(`${this.getApiBaseUrl()}${scopedPath}`, {
 				method,
 				headers: this.getApiHeaders(),
-				body:
-					scopedBody === undefined ? undefined : JSON.stringify(scopedBody),
+				body: requestBody,
 				signal: controller.signal,
 			});
-
 			const text = await response.text();
 			let data = {};
 			try {
@@ -154,7 +153,6 @@ export class NowledgeMemClient {
 			} catch {
 				data = { raw: text };
 			}
-
 			if (!response.ok) {
 				const detail =
 					typeof data?.detail === "string"

package/src/context-engine.js

@@ -166,9 +166,15 @@ function getSessionState(key) {
  * @param {import('./client.js').NowledgeMemClient} client
  * @param {object} cfg  Parsed plugin config
  * @param {object} logger  OpenClaw logger
+ * @param {object} runtime Runtime state helpers supplied by register()
  * @returns {() => object}  Factory that creates the engine instance
  */
-export function createNowledgeMemContextEngineFactory(client, cfg, logger) {
+export function createNowledgeMemContextEngineFactory(
+	client,
+	cfg,
+	logger,
+	runtime = {},
+) {
 	return () => {
 		ceState.active = true;
 		logger.info("nowledge-mem: context engine activated");
@@ -242,8 +248,12 @@ export function createNowledgeMemContextEngineFactory(client, cfg, logger) {
 				}
 
 				// 3. Recalled memories (when sessionContext enabled)
-				// Skipped when corpus supplement handles search-based recall via memory-core.
-				if (cfg.sessionContext && !cfg.corpusSupplement) {
+				// Skip only when corpus supplement is actually active at runtime.
+				const corpusSupplementActive =
+					typeof runtime.isCorpusSupplementActive === "function"
+						? runtime.isCorpusSupplementActive() === true
+						: cfg.corpusSupplement === true;
+				if (cfg.sessionContext && !corpusSupplementActive) {
 					const query = buildAssembleSearchQuery(prompt, messages);
 					if (query) {
 						try {

package/src/hooks/recall.js

@@ -177,13 +177,16 @@ export function buildRecalledKnowledgeBlock(
  * When the context engine is active, this hook is a no-op —
  * assemble() handles recall via systemPromptAddition.
  */
-export function buildRecallHandler(client, cfg, logger) {
+export function buildRecallHandler(client, cfg, logger, runtime = {}) {
 	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;
+	const skipSearchRecall =
+		typeof runtime.skipSearchRecall === "boolean"
+			? runtime.skipSearchRecall
+			: cfg.corpusSupplement;
 
 	return async (event) => {
 		if (ceState.active) return;

package/src/index.js

@@ -80,6 +80,8 @@ export default {
 		const pluginsAllow = api.config?.plugins?.allow;
 		let contextEngineRegistered = false;
 		let contextEngineRegistrationError = null;
+		let corpusSupplementActive = false;
+		let corpusSupplementRegistrationError = null;
 
 		// --- Context Engine registration ---
 		// When the user sets `plugins.slots.contextEngine: "nowledge-mem"` —
@@ -94,6 +96,9 @@ export default {
 				client,
 				cfg,
 				logger,
+				{
+					isCorpusSupplementActive: () => corpusSupplementActive,
+				},
 			);
 			for (const contextEngineId of NOWLEDGE_MEM_CONTEXT_ENGINE_IDS) {
 				api.registerContextEngine(contextEngineId, contextEngineFactory);
@@ -107,17 +112,6 @@ export default {
 			);
 		}
 
-		api.registerTool(
-			createStatusTool(client, logger, cfg, {
-				memorySlot,
-				contextEngineSlot,
-				contextEngineIds: NOWLEDGE_MEM_CONTEXT_ENGINE_IDS,
-				pluginsAllow,
-				contextEngineRegistered,
-				contextEngineRegistrationError,
-			}),
-		);
-
 		// --- 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
@@ -127,18 +121,32 @@ export default {
 				api.registerMemoryCorpusSupplement(
 					createNowledgeMemCorpusSupplement(client, cfg, logger),
 				);
+				corpusSupplementActive = true;
 				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;
+				corpusSupplementRegistrationError = String(err);
 				logger.info?.(
 					`nowledge-mem: corpus supplement unavailable, falling back to normal recall (${err})`,
 				);
 			}
 		}
 
+		api.registerTool(
+			createStatusTool(client, logger, cfg, {
+				memorySlot,
+				contextEngineSlot,
+				contextEngineIds: NOWLEDGE_MEM_CONTEXT_ENGINE_IDS,
+				pluginsAllow,
+				contextEngineRegistered,
+				contextEngineRegistrationError,
+				corpusSupplementActive,
+				corpusSupplementRegistrationError,
+			}),
+		);
+
 		// --- Hooks ---
 		// Behavioral + recall hooks defer to the active CE to avoid duplicate
 		// prompt injection. Capture hooks remain enabled as a backstop because
@@ -151,7 +159,12 @@ export default {
 
 		// Session context: inject Working Memory + recalled memories at prompt time.
 		if (cfg.sessionContext) {
-			api.on("before_prompt_build", buildRecallHandler(client, cfg, logger));
+			api.on(
+				"before_prompt_build",
+				buildRecallHandler(client, cfg, logger, {
+					skipSearchRecall: corpusSupplementActive,
+				}),
+			);
 		}
 
 		// Session digest: capture threads + LLM distillation at lifecycle events.
@@ -182,7 +195,7 @@ export default {
 
 		const remoteMode = !isDefaultApiUrl(cfg.apiUrl);
 		logger.info(
-			`nowledge-mem: initialized (memorySlotSelected=${memorySlotSelected}, context=${cfg.sessionContext}, digest=${cfg.sessionDigest}, corpus=${cfg.corpusSupplement}, mode=${remoteMode ? `remote → ${cfg.apiUrl}` : "local"}, contextEngineIds=${NOWLEDGE_MEM_CONTEXT_ENGINE_ID}|${api.id})`,
+			`nowledge-mem: initialized (memorySlotSelected=${memorySlotSelected}, context=${cfg.sessionContext}, digest=${cfg.sessionDigest}, corpusConfigured=${cfg.corpusSupplement}, corpusActive=${corpusSupplementActive}, mode=${remoteMode ? `remote → ${cfg.apiUrl}` : "local"}, contextEngineIds=${NOWLEDGE_MEM_CONTEXT_ENGINE_ID}|${api.id})`,
 		);
 	},
 };

package/src/tools/status.js

@@ -67,35 +67,62 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 			// 0b. Memory slot check — show current mode and options
 			const memorySlot = runtimeInfo.memorySlot;
 			const contextEngineSlot = runtimeInfo.contextEngineSlot;
-			const contextEngineRegistered = runtimeInfo.contextEngineRegistered === true;
-				const contextEngineRegistrationError =
-					typeof runtimeInfo.contextEngineRegistrationError === "string" &&
-					runtimeInfo.contextEngineRegistrationError.trim()
-						? runtimeInfo.contextEngineRegistrationError.trim()
-						: null;
-				details.memorySlot = memorySlot ?? "(unknown)";
-				const ceSlot =
-					typeof contextEngineSlot === "string" && contextEngineSlot.trim()
-						? contextEngineSlot.trim()
-						: "legacy";
-				details.contextEngineSlot = ceSlot;
-				details.contextEngineRegistered = contextEngineRegistered;
+			const contextEngineRegistered =
+				runtimeInfo.contextEngineRegistered === true;
+			const contextEngineRegistrationError =
+				typeof runtimeInfo.contextEngineRegistrationError === "string" &&
+				runtimeInfo.contextEngineRegistrationError.trim()
+					? runtimeInfo.contextEngineRegistrationError.trim()
+					: null;
+			const corpusSupplementConfigured = cfg.corpusSupplement === true;
+			const corpusSupplementActive =
+				runtimeInfo.corpusSupplementActive === true;
+			const corpusSupplementRegistrationError =
+				typeof runtimeInfo.corpusSupplementRegistrationError === "string" &&
+				runtimeInfo.corpusSupplementRegistrationError.trim()
+					? runtimeInfo.corpusSupplementRegistrationError.trim()
+					: null;
+			details.memorySlot = memorySlot ?? "(unknown)";
+			details.corpusSupplementConfigured = corpusSupplementConfigured;
+			details.corpusSupplementActive = corpusSupplementActive;
+			if (corpusSupplementRegistrationError) {
+				details.corpusSupplementRegistrationError =
+					corpusSupplementRegistrationError;
+			}
+			const ceSlot =
+				typeof contextEngineSlot === "string" && contextEngineSlot.trim()
+					? contextEngineSlot.trim()
+					: "legacy";
+			details.contextEngineSlot = ceSlot;
+			details.contextEngineRegistered = contextEngineRegistered;
 			if (memorySlot && memorySlot !== "openclaw-nowledge-mem") {
-				const corpusOn = cfg.corpusSupplement === true;
-				if (corpusOn) {
-					lines.push(
-						`Memory slot: "${memorySlot}" + corpus supplement active`,
-					);
+				if (corpusSupplementConfigured && corpusSupplementActive) {
+					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}"`,
-					);
+				} else if (corpusSupplementConfigured && !corpusSupplementActive) {
+					lines.push(`ℹ Memory slot: "${memorySlot}"`);
 					lines.push(
-						"  Two options:",
+						"  corpusSupplement is configured, but host registration is unavailable in this runtime.",
 					);
+					if (cfg.sessionContext) {
+						lines.push(
+							"  Fallback active: Nowledge Mem still injects Working Memory and uses its own recall path.",
+						);
+					} else {
+						lines.push(
+							"  Fallback: Nowledge Mem tools remain available. Enable sessionContext for prompt-time Working Memory and recall.",
+						);
+					}
+					if (corpusSupplementRegistrationError) {
+						lines.push(
+							`  Supplement registration detail: ${corpusSupplementRegistrationError}`,
+						);
+					}
+				} 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',
 					);
@@ -113,7 +140,9 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 				isNowledgeMemContextEngineSlot(ceSlot) && contextEngineRegistered;
 			const captureMode = !cfg.sessionDigest
 				? "disabled"
-				: ceActive ? "context-engine+hooks" : "hooks";
+				: ceActive
+					? "context-engine+hooks"
+					: "hooks";
 			details.captureMode = captureMode;
 			if (ceActive) {
 				if (ceSlot === NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS) {
@@ -124,7 +153,9 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 						`  OpenClaw selected the plugin id for the context-engine slot. ${NOWLEDGE_MEM_CONTEXT_ENGINE_ID} remains the canonical manual setting.`,
 					);
 				} else {
-					lines.push(`Context Engine slot: ${NOWLEDGE_MEM_CONTEXT_ENGINE_ID} (active)`);
+					lines.push(
+						`Context Engine slot: ${NOWLEDGE_MEM_CONTEXT_ENGINE_ID} (active)`,
+					);
 				}
 				lines.push(
 					"  Thread capture runs through Context Engine afterTurn with hook fallback (agent_end, after_compaction, before_reset).",
@@ -146,7 +177,9 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 					"  The slot points to Nowledge Mem, but Context Engine registration is not active in this runtime. Thread capture is using hooks only.",
 				);
 				if (contextEngineRegistrationError) {
-					lines.push(`  CE registration detail: ${contextEngineRegistrationError}`);
+					lines.push(
+						`  CE registration detail: ${contextEngineRegistrationError}`,
+					);
 				}
 			} else {
 				lines.push(
@@ -268,6 +301,14 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 			lines.push(
 				`  corpusSupplement: ${cfg.corpusSupplement} (${sources.corpusSupplement || "?"})`,
 			);
+			if (corpusSupplementConfigured) {
+				const fallbackText = cfg.sessionContext
+					? "configured but unavailable (fallback to plugin recall)"
+					: "configured but unavailable (sessionContext disabled)";
+				lines.push(
+					`  corpusSupplement runtime: ${corpusSupplementActive ? "active" : fallbackText}`,
+				);
+			}
 
 			details.config = {
 				sessionContext: {
@@ -297,6 +338,7 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 				corpusSupplement: {
 					value: cfg.corpusSupplement,
 					source: sources.corpusSupplement,
+					active: corpusSupplementActive,
 				},
 				apiUrl: { value: cfg.apiUrl || "(local)", source: sources.apiUrl },
 				apiKey: {