@nowledge/openclaw-nowledge-mem 0.8.16 → 0.8.19

package/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to the Nowledge Mem OpenClaw plugin will be documented in th
 
 ## Unreleased
 
+## [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
+
+- OpenClaw installs no longer break when the installer writes `plugins.slots.contextEngine: "openclaw-nowledge-mem"` instead of the canonical manual id `nowledge-mem`. The plugin now registers a compatibility alias for that slot value, so users do not need to patch local config after install just to activate the Context Engine.
+
+### Changed
+
+- `nowledge_mem_status` now explains when OpenClaw selected the plugin id as a context-engine compatibility alias, while still treating `nowledge-mem` as the canonical manual config value.
+
+## [0.8.17] - 2026-04-16
+
+### Fixed
+
+- ClawHub installs no longer ship the plugin test suite inside the published code-plugin artifact. The package now uses an explicit `.clawhubignore`, so OpenClaw's security scanner no longer blocks install or update on harmless test-only `child_process` and `process.env + fetch` patterns.
+
 ## [0.8.16] - 2026-04-15
 
 ### Fixed

package/CLAUDE.md

@@ -9,7 +9,7 @@ Continuation guide for `community/nowledge-mem-openclaw-plugin`.
 - Memory backend: `nmem` CLI (fallback: `uvx --from nmem-cli nmem`)
 - 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.
+- Context engine: registered under the canonical id `nowledge-mem` plus the compatibility alias `openclaw-nowledge-mem`. Activated when OpenClaw sets either value in `plugins.slots.contextEngine`. Manual config should still prefer `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.
 - Ambient space lane: prefer plugin config `space` or `spaceTemplate`. Use `NMEM_SPACE` only when OpenClaw is launched in one stable lane and there is no better profile-owned config surface. Legacy `NMEM_SPACE_ID` still works for older setups.
 
@@ -85,7 +85,7 @@ Enable when memory-core is the memory slot and you want cross-tool knowledge to
 The plugin is published as a dual-role OpenClaw plugin (`kind: ["memory", "context-engine"]`). These roles remain independent at runtime:
 
 - **Memory slot**: provides `memory_search` + `memory_get` and activates OpenClaw's "Memory Recall" system prompt section only when `plugins.slots.memory = "openclaw-nowledge-mem"`. In supplement mode with `memory-core`, these compatibility tools stay off so memory-core keeps owning that surface.
-- **Context engine**: activated when user sets `plugins.slots.contextEngine: "nowledge-mem"`. Replaces hooks with richer CE lifecycle.
+- **Context engine**: activated when OpenClaw sets `plugins.slots.contextEngine` to `nowledge-mem` or the compatibility alias `openclaw-nowledge-mem`. Manual config should still use `nowledge-mem`. Replaces hooks with richer CE lifecycle.
 
 ### CE vs Hooks (dual-path design)
 

package/README.md

@@ -17,7 +17,14 @@ This is not a flat note store. Nowledge Mem links related knowledge into a graph
 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.
+OpenClaw's installer writes the install record, enables the plugin, and switches the `memory` slot to `openclaw-nowledge-mem`. On current OpenClaw builds, that same install flow may also set `plugins.slots.contextEngine` to `openclaw-nowledge-mem`. Plugin `0.8.18+` accepts that automatically as a compatibility alias, so you do not need to hand-edit the file after install. If you manage config manually, keep using the canonical context engine id `nowledge-mem`.
+
+Restart OpenClaw after install to load it.
+
+If OpenClaw previously blocked the ClawHub package with a warning about
+`dangerous code patterns detected`, update to `0.8.17+`. That release removes
+test-only files from the published ClawHub artifact, so the installer no longer
+scans harmless development fixtures as if they were runtime plugin code.
 
 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:
 
@@ -560,6 +567,8 @@ If your config enables `plugins.slots.contextEngine: "nowledge-mem"`:
 - on `0.8.6+`, Context Engine capture stays active and hooks remain enabled as a safety net
 - on `0.8.5` and earlier, temporarily removing the `contextEngine` slot is a valid isolation step if thread sync stops while tools still work
 
+If OpenClaw selected `plugins.slots.contextEngine: "openclaw-nowledge-mem"` during install, plugin `0.8.18+` treats that as the same engine. You only need to rewrite it to `"nowledge-mem"` if you want the config to use the canonical manual id.
+
 Remember: OpenClaw applies plugin setting changes after restart. If you turned `sessionDigest` off earlier but had not restarted yet, thread sync could appear to keep working until the next restart, then stop.
 
 What healthy OpenClaw thread sync looks like:

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.16",
+  "version": "0.8.19",
 	"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.16",
+	"version": "0.8.19",
 	"type": "module",
 	"description": "Nowledge Mem memory plugin for OpenClaw, local-first personal knowledge base",
 	"author": {
@@ -25,7 +25,9 @@
 		"openclaw.plugin.json"
 	],
 	"openclaw": {
-		"extensions": ["./src/index.js"],
+		"extensions": [
+			"./src/index.js"
+		],
 		"install": {
 			"npmSpec": "@nowledge/openclaw-nowledge-mem"
 		},

package/src/context-engine-ids.js

@@ -0,0 +1,15 @@
+export const NOWLEDGE_MEM_CONTEXT_ENGINE_ID = "nowledge-mem";
+export const NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS =
+	"openclaw-nowledge-mem";
+
+export const NOWLEDGE_MEM_CONTEXT_ENGINE_IDS = [
+	NOWLEDGE_MEM_CONTEXT_ENGINE_ID,
+	NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS,
+];
+
+export function isNowledgeMemContextEngineSlot(value) {
+	return (
+		typeof value === "string" &&
+		NOWLEDGE_MEM_CONTEXT_ENGINE_IDS.includes(value.trim())
+	);
+}

package/src/context-engine.js

@@ -3,7 +3,9 @@
  *
  * Registers alongside the memory slot (plugin kind includes both "memory" and
  * "context-engine"). When users activate
- * this CE via `plugins.slots.contextEngine: "nowledge-mem"`, it takes over
+ * this CE via `plugins.slots.contextEngine: "nowledge-mem"` (or the
+ * compatibility alias `openclaw-nowledge-mem` written by current installer
+ * builds), it takes over
  * prompt assembly and adds richer lifecycle behavior:
  *
  *   assemble()              — behavioral guidance + recalled memories via systemPromptAddition
@@ -164,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");
@@ -240,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

@@ -6,6 +6,10 @@ import {
 	createRememberCommand,
 } from "./commands/slash.js";
 import { isDefaultApiUrl, parseConfig } from "./config.js";
+import {
+	NOWLEDGE_MEM_CONTEXT_ENGINE_ID,
+	NOWLEDGE_MEM_CONTEXT_ENGINE_IDS,
+} from "./context-engine-ids.js";
 import { createNowledgeMemContextEngineFactory } from "./context-engine.js";
 import { createNowledgeMemCorpusSupplement } from "./corpus-supplement.js";
 import { buildBehavioralHook } from "./hooks/behavioral.js";
@@ -76,18 +80,29 @@ 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"`,
-		// this CE takes over prompt assembly from the hooks below (assemble
-		// replaces behavioral + recall prompt injection). Capture hooks remain
-		// enabled as a reliability backstop because thread sync is idempotent.
-		// When the CE slot points elsewhere, hooks continue working as before.
+		// When the user sets `plugins.slots.contextEngine: "nowledge-mem"` —
+		// or OpenClaw auto-selects the plugin id compatibility alias
+		// `openclaw-nowledge-mem` during install — this CE takes over prompt
+		// assembly from the hooks below (assemble replaces behavioral + recall
+		// prompt injection). Capture hooks remain enabled as a reliability
+		// backstop because thread sync is idempotent. When the CE slot points
+		// elsewhere, hooks continue working as before.
 		try {
-			api.registerContextEngine(
-				"nowledge-mem",
-				createNowledgeMemContextEngineFactory(client, cfg, logger),
+			const contextEngineFactory = createNowledgeMemContextEngineFactory(
+				client,
+				cfg,
+				logger,
+				{
+					isCorpusSupplementActive: () => corpusSupplementActive,
+				},
 			);
+			for (const contextEngineId of NOWLEDGE_MEM_CONTEXT_ENGINE_IDS) {
+				api.registerContextEngine(contextEngineId, contextEngineFactory);
+			}
 			contextEngineRegistered = true;
 		} catch (err) {
 			// OpenClaw < CE support — degrade gracefully to hooks-only mode
@@ -97,16 +112,6 @@ export default {
 			);
 		}
 
-		api.registerTool(
-			createStatusTool(client, logger, cfg, {
-				memorySlot,
-				contextEngineSlot,
-				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
@@ -116,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
@@ -140,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.
@@ -171,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"})`,
+			`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

@@ -6,6 +6,11 @@
  * Shows where each config value comes from (file, pluginConfig, env, default).
  */
 import { isDefaultApiUrl } from "../config.js";
+import {
+	NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS,
+	NOWLEDGE_MEM_CONTEXT_ENGINE_ID,
+	isNowledgeMemContextEngineSlot,
+} from "../context-engine-ids.js";
 
 export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 	return {
@@ -62,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 {
+				} else if (corpusSupplementConfigured && !corpusSupplementActive) {
+					lines.push(`ℹ Memory slot: "${memorySlot}"`);
 					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',
 					);
@@ -104,23 +136,50 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 			}
 
 			// 0c. Capture routing — hooks vs context engine
-			const ceActive = ceSlot === "nowledge-mem" && contextEngineRegistered;
+			const ceActive =
+				isNowledgeMemContextEngineSlot(ceSlot) && contextEngineRegistered;
 			const captureMode = !cfg.sessionDigest
 				? "disabled"
-				: ceActive ? "context-engine+hooks" : "hooks";
+				: ceActive
+					? "context-engine+hooks"
+					: "hooks";
 			details.captureMode = captureMode;
 			if (ceActive) {
-				lines.push("Context Engine slot: nowledge-mem (active)");
+				if (ceSlot === NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS) {
+					lines.push(
+						`Context Engine slot: ${NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS} (active via compatibility alias)`,
+					);
+					lines.push(
+						`  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(
 					"  Thread capture runs through Context Engine afterTurn with hook fallback (agent_end, after_compaction, before_reset).",
 				);
-			} else if (ceSlot === "nowledge-mem") {
-				lines.push("Context Engine slot: nowledge-mem (configured, fallback to hooks)");
+			} else if (isNowledgeMemContextEngineSlot(ceSlot)) {
+				if (ceSlot === NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS) {
+					lines.push(
+						`Context Engine slot: ${NOWLEDGE_MEM_CONTEXT_ENGINE_COMPAT_ALIAS} (compatibility alias, fallback to hooks)`,
+					);
+					lines.push(
+						`  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} (configured, fallback to hooks)`,
+					);
+				}
 				lines.push(
 					"  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(
@@ -242,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: {
@@ -271,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: {