@nowledge/openclaw-nowledge-mem 0.8.3 → 0.8.8

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 All notable changes to the Nowledge Mem OpenClaw plugin will be documented in this file.
 
+## [0.8.8] - 2026-04-09
+
+### Fixed
+
+- **Internal OpenClaw control sender wrappers no longer leak into saved thread content.** Messages wrapped with `Sender (untrusted metadata)` for the internal `openclaw-control-ui` source now persist only the user-visible message body, instead of storing the control metadata block in Mem.
+
+## [0.8.7] - 2026-04-09
+
+### Fixed
+
+- **One OpenClaw chat now persists as one Mem thread.** Thread identity now prefers the stable OpenClaw `sessionKey` over transient runtime `sessionId`, so Context Engine `afterTurn` capture and hook-based `agent_end` capture append to the same thread instead of creating parallel copies of the same conversation.
+- **Internal OpenClaw helper sessions no longer pollute Mem.** Temporary sessions like `temp:slug-generator` and internal subagent sessions are now excluded from thread auto-sync, keeping the thread list focused on real user conversations.
+- **Stored thread content is cleaner.** The synthetic `/new` or `/reset` startup prompt is no longer persisted as a user message, and OpenClaw control tags like `[[reply_to_current]]` / `[[reply_to:...]]` / `[[audio_as_voice]]` are stripped before capture.
+
+## [0.8.6] - 2026-04-09
+
+### Fixed
+
+- **Thread capture no longer depends entirely on the Context Engine path.** When `plugins.slots.contextEngine` points to `nowledge-mem`, behavioral and recall prompt injection still defer to the Context Engine, but capture hooks now remain active as a safety net. Thread append/create is already tail-synced and idempotent, so this backstop avoids missed syncs on sessions where the Context Engine lifecycle does not fire as expected without reintroducing duplicate threads.
+
+### Changed
+
+- **Troubleshooting now distinguishes sandbox mode from capture mode.** A `session_status` label like `direct/non-main` reflects OpenClaw sandbox configuration, not a cron or non-interactive session. The OpenClaw main session key `agent:main:main` remains a normal interactive capture target.
+- **Status now reports Context Engine activity precisely.** `nowledge_mem_status` only reports Context Engine capture as active when registration actually succeeded in the current runtime. If the slot points to `nowledge-mem` but the runtime falls back to hooks-only mode, the status output now says so directly.
+
+## [0.8.5] - 2026-04-09
+
+### Changed
+
+- **Reduced loader coupling in the published package.** `openclaw.install.minHostVersion` and `peerDependencies.openclaw` have been removed. The plugin already uses runtime feature detection and graceful fallback, so those package-level host constraints were unnecessary. `openclaw.compat.pluginApi` and `openclaw.build.openclawVersion` remain for ClawHub validation.
+- **`nowledge_mem_status` now explains capture routing and transport split.** It reports whether thread capture is running through lifecycle hooks or Context Engine `afterTurn`, and makes the transport model explicit: memory tools use the `nmem` CLI, while thread auto-sync uses the Mem HTTP API. This closes the common debugging gap where search works but thread sync does not.
+
 ## [0.8.3] - 2026-04-08
 
 ### Added

package/CLAUDE.md

@@ -94,7 +94,7 @@ A shared `ceState.active` flag (in `ce-state.js`) coordinates the two paths:
 |-----------|-----------|---------------------|
 | Behavioral guidance | `assemble()` → `systemPromptAddition` | `before_prompt_build` → `appendSystemContext` |
 | Memory recall | `assemble()` → `systemPromptAddition` | `before_prompt_build` → `appendSystemContext` |
-| Thread capture | `afterTurn()` (every turn) | `agent_end` / `after_compaction` / `before_reset` |
+| Thread capture | `afterTurn()` (every turn) + hook fallback | `agent_end` / `after_compaction` / `before_reset` |
 | Triage + distill | `afterTurn()` | `agent_end` only |
 | Compaction | `compact()` with memory-aware instructions | None (OpenClaw legacy) |
 | Subagent context | `prepareSubagentSpawn()` + `onSubagentEnded()` | None |

package/README.md

@@ -365,7 +365,7 @@ The behavioral guidance adjusts when `sessionContext` is enabled. Instead of "se
 
 **What happens to conversations I don't explicitly save?**
 
-With `sessionDigest` enabled (the default), every conversation is saved as a searchable thread. You can find it later with `nowledge_mem_thread_search`. On top of that, a lightweight LLM triage checks if the conversation contained decisions, insights, or preferences worth keeping as structured memories. If yes, they're extracted with proper types, labels, and temporal context. If the conversation was routine ("fix this typo"), nothing extra is saved.
+With `sessionDigest` enabled (the default), every conversation is saved as a searchable thread. One OpenClaw chat becomes one Mem thread: capture uses the stable OpenClaw `sessionKey`, not transient runtime ids, so Context Engine capture and hook-based capture append to the same conversation. Internal helper sessions like `temp:*` and subagent runs are excluded, so your recent threads stay focused on real chats. On top of thread capture, a lightweight LLM triage checks if the conversation contained decisions, insights, or preferences worth keeping as structured memories. If yes, they're extracted with proper types, labels, and temporal context. If the conversation was routine ("fix this typo"), nothing extra is saved.
 
 **Can memories be wrong or outdated?**
 
@@ -408,15 +408,15 @@ To change settings, use the OpenClaw plugin settings UI. Changes take effect on
 
 ### Remote access
 
-Create `~/.nowledge-mem/config.json` with your credentials. This file is shared by all Nowledge Mem integrations (nmem CLI, Bub, Claude Code, etc.) so one file connects everything:
+Configure this machine once:
 
-```json
-{
-  "apiUrl": "https://<your-url>",
-  "apiKey": "nmem_..."
-}
+```bash
+nmem config client set url https://<your-url>
+nmem config client set api-key nmem_...
 ```
 
+That writes the shared local client config used by `nmem`, OpenClaw, Bub, Claude Code, and other integrations on this machine. You can still set **Server URL** and **API key** in the OpenClaw dashboard if you want plugin-specific overrides.
+
 See [Access Mem Anywhere](https://mem.nowledge.co/docs/remote-access).
 
 ### Advanced: environment variables
@@ -449,7 +449,7 @@ Credentials (apiUrl, apiKey):
 openclaw.json (legacy) > OpenClaw dashboard > config.json (shared) > env vars > defaults
 ```
 
-`~/.nowledge-mem/openclaw.json` is still honored for backward compatibility but is no longer the recommended path. New users should configure plugin-specific settings via the OpenClaw dashboard and shared credentials via `~/.nowledge-mem/config.json`.
+`~/.nowledge-mem/openclaw.json` is still honored for backward compatibility but is no longer the recommended path. New users should configure plugin-specific settings via the OpenClaw dashboard and shared credentials via `nmem config client ...`.
 
 Use `nowledge_mem_status` (or `openclaw nowledge-mem status`) to see where each value comes from.
 
@@ -505,6 +505,41 @@ If `openclaw status` shows a CRITICAL warning about `plugins.allow`, this is the
 
 Do not list `nowledge_mem_*` tool names in `tools.allow` — OpenClaw silently strips allowlists that contain only plugin entries, so the config looks active but does nothing.
 
+**Memory tools still work, but thread auto-sync does not**
+
+This is usually a capture-path issue, not a search/save issue:
+
+- memory tools use the local `nmem` CLI
+- thread auto-sync uses the Mem HTTP API
+- cron / isolated automation sessions are intentionally excluded from capture in `0.8.x`
+
+Run `nowledge_mem_status` in a conversation and check, in this order:
+
+- the plugin is loaded
+- `sessionDigest` is still `true`
+- the backend is reachable
+- which capture path is active: hook events, or Context Engine `afterTurn` with hook fallback
+- whether you changed plugin settings recently without restarting OpenClaw yet
+
+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
+
+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:
+
+- one visible chat becomes one Mem thread
+- helper sessions like `temp:slug-generator` do not appear
+- the synthetic `/new` / `/reset` startup prompt is not stored as the first user message
+
+To inspect the recent synced threads directly, run:
+
+```bash
+nmem t list --source openclaw -n 20
+```
+
 **Search timeouts with many concurrent agents**
 
 When running many agents in parallel, all searches share a single database connection. Upgrade to Nowledge Mem v0.6.12+ (backend) so scoring writes no longer block search responses.
@@ -515,7 +550,7 @@ The Nowledge Mem backend is not running. Start it from the desktop app, or run t
 
 **Remote mode not connecting**
 
-Check `~/.nowledge-mem/config.json` credentials. Run `nmem --json --api-url "$URL" status` to verify the server is reachable.
+Run `nmem config client show` and confirm the effective URL and API key state. Then run `nmem --json --api-url "$URL" status` to verify the server is reachable.
 
 ## What Makes This Different
 

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.3",
+	"version": "0.8.8",
 	"kind": "memory",
 	"skills": [
 		"skills/memory-guide"

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@nowledge/openclaw-nowledge-mem",
 	"displayName": "Nowledge Mem for OpenClaw",
-	"version": "0.8.3",
+	"version": "0.8.8",
 	"type": "module",
 	"description": "Nowledge Mem memory plugin for OpenClaw, local-first personal knowledge base",
 	"author": {
@@ -27,8 +27,7 @@
 	"openclaw": {
 		"extensions": ["./src/index.js"],
 		"install": {
-			"npmSpec": "@nowledge/openclaw-nowledge-mem",
-			"minHostVersion": ">=2026.4.5"
+			"npmSpec": "@nowledge/openclaw-nowledge-mem"
 		},
 		"compat": {
 			"pluginApi": ">=2026.4.5"
@@ -47,9 +46,6 @@
 		"lint": "biome check .",
 		"format": "biome format --write ."
 	},
-	"peerDependencies": {
-		"openclaw": ">=2026.4.5"
-	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.0"
 	}

package/src/ce-state.js

@@ -1,8 +1,8 @@
 /**
  * Shared mutable state flag for context engine activation.
  *
- * When the CE is bootstrapped, `active` is set to true. Event hooks
- * check this flag to avoid duplicate work — the CE's lifecycle methods
- * (assemble, afterTurn, etc.) replace hook behavior when active.
+ * When the CE is bootstrapped, `active` is set to true. Prompt-building hooks
+ * use this to avoid duplicate context injection. Capture hooks stay enabled as
+ * a safety net because thread sync is already tail-synced and idempotent.
  */
 export const ceState = { active: false };

package/src/context-engine.js

@@ -2,8 +2,8 @@
  * Nowledge Mem Context Engine for OpenClaw.
  *
  * Registers alongside the memory slot (kind: "memory"). When users activate
- * this CE via `plugins.slots.contextEngine: "nowledge-mem"`, it replaces the
- * hook-based approach with the richer CE lifecycle:
+ * this CE via `plugins.slots.contextEngine: "nowledge-mem"`, it takes over
+ * prompt assembly and adds richer lifecycle behavior:
  *
  *   assemble()              — behavioral guidance + recalled memories via systemPromptAddition
  *   afterTurn()             — continuous thread capture + triage/distillation (every turn)
@@ -12,7 +12,9 @@
  *   bootstrap()             — pre-warm Working Memory for first assemble
  *
  * When not activated, the existing hooks (behavioral, recall, capture) work
- * as before — full backward compatibility.
+ * as before. When activated, behavioral + recall hooks defer to the CE to
+ * avoid duplicate prompt context, while capture hooks remain as a safe
+ * fallback if a CE post-turn lifecycle is missed.
  *
  * Design:
  * - ownsCompaction: false — we enhance compaction instructions, not the algorithm
@@ -25,6 +27,7 @@ import { BASE_GUIDANCE, SESSION_CONTEXT_GUIDANCE } from "./hooks/behavioral.js";
 import {
 	appendOrCreateThread,
 	hasSkipMarker,
+	isInternalCaptureSessionKey,
 	isCronCaptureSessionKey,
 	matchesExcludePattern,
 	triageAndDistill,
@@ -356,6 +359,10 @@ export function createNowledgeMemContextEngineFactory(client, cfg, logger) {
 					logger.debug?.(`ce: skipped cron session ${normalizedKey}`);
 					return;
 				}
+				if (isInternalCaptureSessionKey(normalizedKey)) {
+					logger.debug?.(`ce: skipped internal session ${normalizedKey}`);
+					return;
+				}
 
 				// Capture exclusion: pattern-based and marker-based filters
 				if (matchesExcludePattern(normalizedKey, cfg.captureExclude)) {

package/src/hooks/capture.js

@@ -1,12 +1,17 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { isCronSessionKey } from "openclaw/plugin-sdk/routing";
-import { ceState } from "../ce-state.js";
+import { isCronSessionKey, isSubagentSessionKey } from "openclaw/plugin-sdk/routing";
 
 export const DEFAULT_MAX_MESSAGE_CHARS = 800;
 export const MAX_DISTILL_MESSAGE_CHARS = 2000;
 export const MAX_CONVERSATION_CHARS = 30_000;
 export const MIN_MESSAGES_FOR_DISTILL = 4;
+const SESSION_RESET_PROMPT_PREFIX =
+	"A new session was started via /new or /reset.";
+const OPENCLAW_DIRECTIVE_TAG_RE =
+	/\s*\[\[\s*(?:audio_as_voice|reply_to_current|reply_to\s*:\s*[^\]\n]+)\s*\]\]\s*/giu;
+const OPENCLAW_INTERNAL_SENDER_BLOCK_RE =
+	/^Sender \(untrusted metadata\):\s*```json\s*([\s\S]*?)\s*```\s*([\s\S]*)$/iu;
 
 // Per-thread triage cooldown: prevents burst triage/distillation from heartbeat.
 // Maps threadId -> timestamp (ms) of last successful triage.
@@ -113,6 +118,52 @@ export function hasSkipMarker(messages, marker) {
 	});
 }
 
+/**
+ * Internal helper / system sessions should not become user-facing Mem threads.
+ *
+ * - temp:* covers OpenClaw helper sessions such as slug generation
+ * - subagent sessions are execution internals, not first-class user chats
+ */
+export function isInternalCaptureSessionKey(sessionKey) {
+	const raw = String(sessionKey || "")
+		.trim()
+		.toLowerCase();
+	if (!raw) return false;
+	if (raw.startsWith("temp:")) return true;
+	return isSubagentSessionKey(raw);
+}
+
+function stripOpenClawDirectiveTags(text) {
+	return String(text || "")
+		.replace(OPENCLAW_DIRECTIVE_TAG_RE, " ")
+		.replace(/[ \t]+\n/g, "\n")
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+}
+
+function stripInternalSenderMetadata(text) {
+	const raw = String(text || "").trim();
+	if (!raw.startsWith("Sender (untrusted metadata):")) return raw;
+	const match = raw.match(OPENCLAW_INTERNAL_SENDER_BLOCK_RE);
+	if (!match) return raw;
+	const [, jsonBlock, remainder] = match;
+	try {
+		const parsed = JSON.parse(jsonBlock);
+		const label = String(parsed?.label || "")
+			.trim()
+			.toLowerCase();
+		const id = String(parsed?.id || "")
+			.trim()
+			.toLowerCase();
+		if (label === "openclaw-control-ui" || id === "openclaw-control-ui") {
+			return String(remainder || "").trim();
+		}
+	} catch {
+		return raw;
+	}
+	return raw;
+}
+
 // ---------------------------------------------------------------------------
 // Message normalization utilities
 // ---------------------------------------------------------------------------
@@ -151,7 +202,13 @@ export function normalizeRoleMessage(
 		raw.message && typeof raw.message === "object" ? raw.message : raw;
 	const role = typeof msg.role === "string" ? msg.role : "";
 	if (role !== "user" && role !== "assistant") return null;
-	const text = extractText(msg.content);
+	const extractedText = extractText(msg.content);
+	if (!extractedText) return null;
+	const cleanedText = stripInternalSenderMetadata(extractedText);
+	if (role === "user" && cleanedText.startsWith(SESSION_RESET_PROMPT_PREFIX)) {
+		return null;
+	}
+	const text = stripOpenClawDirectiveTags(cleanedText);
 	if (!text) return null;
 	if (role === "user" && text.startsWith("/")) return null;
 
@@ -184,10 +241,9 @@ export function normalizeRoleMessage(
 	};
 }
 
-export function buildThreadTitle(ctx, reason) {
+export function buildThreadTitle(ctx) {
 	const session = ctx?.sessionKey || ctx?.sessionId || "session";
-	const reasonSuffix = reason ? ` (${reason})` : "";
-	return `OpenClaw ${session}${reasonSuffix}`;
+	return `OpenClaw ${session}`;
 }
 
 function sanitizeIdPart(input, max = 48) {
@@ -201,8 +257,8 @@ function sanitizeIdPart(input, max = 48) {
 
 export function buildStableThreadId(event, ctx) {
 	const base =
-		String(ctx?.sessionId || "").trim() ||
 		String(ctx?.sessionKey || "").trim() ||
+		String(ctx?.sessionId || "").trim() ||
 		String(event?.sessionFile || "").trim() ||
 		"session";
 	const slug = sanitizeIdPart(base);
@@ -282,7 +338,7 @@ export async function appendOrCreateThread({
 	const threadId = buildStableThreadId(event, ctx);
 	const sessionKey = String(ctx?.sessionKey || ctx?.sessionId || "session");
 	const sessionId = String(ctx?.sessionId || "").trim();
-	const title = buildThreadTitle(ctx, reason);
+	const title = buildThreadTitle(ctx);
 	const normalized = rawMessages
 		.map((message) => normalizeRoleMessage(message, maxMessageChars))
 		.filter(Boolean);
@@ -457,7 +513,7 @@ export async function triageAndDistill({
 
 		const distillResult = await client.distillThread({
 			threadId: captureResult.threadId,
-			title: buildThreadTitle(ctx, "distilled"),
+			title: buildThreadTitle(ctx),
 			content: conversationText,
 		});
 
@@ -477,8 +533,9 @@ export async function triageAndDistill({
 /**
  * Capture thread + LLM-based distillation after a successful agent run.
  *
- * When the context engine is active, this hook is a no-op — afterTurn
- * handles capture and distillation through the CE lifecycle.
+ * Even when the context engine is active, this hook remains as a safety net.
+ * Thread append/create is already idempotent, so the hook path can safely
+ * backstop CE afterTurn without duplicating stored messages.
  *
  * Heartbeat sessions (ctx.trigger === "heartbeat") are skipped — they
  * produce repetitive status pings that aren't worth preserving.
@@ -487,7 +544,6 @@ export async function triageAndDistill({
  */
 export function buildAgentEndCaptureHandler(client, cfg, logger) {
 	return async (event, ctx) => {
-		if (ceState.active) return;
 		if (!event?.success) return;
 		if (ctx?.trigger === "heartbeat") return;
 
@@ -496,6 +552,10 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
 			logger.debug?.(`capture: skipped cron session ${sessionKey}`);
 			return;
 		}
+		if (isInternalCaptureSessionKey(sessionKey)) {
+			logger.debug?.(`capture: skipped internal session ${sessionKey}`);
+			return;
+		}
 
 		// Pattern-based exclusion (e.g. subagent sessions, custom jobs)
 		if (matchesExcludePattern(sessionKey, cfg.captureExclude)) {
@@ -530,14 +590,13 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
  * Capture thread messages before reset or after compaction.
  * Thread-only (no distillation) — these are lifecycle checkpoints.
  *
- * When the context engine is active, this hook is a no-op — afterTurn
- * handles capture through the CE lifecycle.
+ * This hook also stays enabled when the context engine is active.
+ * The shared tail-sync dedup keeps the fallback path cheap and safe.
  *
  * Heartbeat sessions are skipped (same rationale as agent_end).
  */
 export function buildBeforeResetCaptureHandler(client, cfg, logger) {
 	return async (event, ctx) => {
-		if (ceState.active) return;
 		if (ctx?.trigger === "heartbeat") return;
 
 		const sessionKey = String(ctx?.sessionKey || ctx?.sessionId || "");
@@ -545,6 +604,10 @@ export function buildBeforeResetCaptureHandler(client, cfg, logger) {
 			logger.debug?.(`capture: skipped cron session ${sessionKey}`);
 			return;
 		}
+		if (isInternalCaptureSessionKey(sessionKey)) {
+			logger.debug?.(`capture: skipped internal session ${sessionKey}`);
+			return;
+		}
 
 		if (matchesExcludePattern(sessionKey, cfg.captureExclude)) {
 			logger.debug?.(`capture: skipped excluded session ${sessionKey}`);

package/src/index.js

@@ -57,30 +57,43 @@ export default {
 
 		// Diagnostics — pass runtime config so the status tool can detect:
 		//   - plugins.allow missing or not including this plugin
-		//   - memory slot pointing elsewhere (e.g. memory-core)
+		//   - memory/context-engine slot routing for capture and recall
 		const memorySlot = api.config?.plugins?.slots?.memory;
+		const contextEngineSlot = api.config?.plugins?.slots?.contextEngine;
 		const pluginsAllow = api.config?.plugins?.allow;
-		api.registerTool(
-			createStatusTool(client, logger, cfg, { memorySlot, pluginsAllow }),
-		);
+		let contextEngineRegistered = false;
+		let contextEngineRegistrationError = null;
 
 		// --- Context Engine registration ---
 		// When the user sets `plugins.slots.contextEngine: "nowledge-mem"`,
-		// this CE takes over from the hooks below (assemble replaces behavioral
-		// + recall; afterTurn replaces agent_end + capture hooks). When the CE
-		// slot points elsewhere, hooks continue working as before.
+		// 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),
 			);
+			contextEngineRegistered = true;
 		} catch (err) {
 			// OpenClaw < CE support — degrade gracefully to hooks-only mode
+			contextEngineRegistrationError = String(err);
 			logger.debug?.(
 				`nowledge-mem: context engine registration unavailable (${err}), using hooks`,
 			);
 		}
 
+		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
@@ -102,9 +115,10 @@ export default {
 			}
 		}
 
-		// --- 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.
+		// --- Hooks ---
+		// Behavioral + recall hooks defer to the active CE to avoid duplicate
+		// prompt injection. Capture hooks remain enabled as a backstop because
+		// thread append/create is tail-synced and idempotent.
 
 		// Always-on: behavioral guidance so the agent proactively saves and searches.
 		// Fires every turn via before_prompt_build — ~50 tokens, negligible cost.

package/src/tools/status.js

@@ -61,7 +61,20 @@ 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 =
+				contextEngineSlot && String(contextEngineSlot).trim()
+					? String(contextEngineSlot).trim()
+					: "legacy";
+			details.contextEngineSlot = ceSlot;
+			details.contextEngineRegistered = contextEngineRegistered;
 			if (memorySlot && memorySlot !== "openclaw-nowledge-mem") {
 				const corpusOn = cfg.corpusSupplement === true;
 				if (corpusOn) {
@@ -90,6 +103,39 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 				lines.push("Memory slot: openclaw-nowledge-mem (active)");
 			}
 
+			// 0c. Capture routing — hooks vs context engine
+			const ceActive = ceSlot === "nowledge-mem" && contextEngineRegistered;
+			const captureMode = !cfg.sessionDigest
+				? "disabled"
+				: ceActive ? "context-engine+hooks" : "hooks";
+			details.captureMode = captureMode;
+			if (ceActive) {
+				lines.push("Context Engine slot: nowledge-mem (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)");
+				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}`);
+				}
+			} else {
+				lines.push(
+					`Context Engine slot: ${ceSlot === "legacy" ? "legacy (default)" : `"${ceSlot}"`}`,
+				);
+				if (cfg.sessionDigest) {
+					lines.push(
+						"  Thread capture runs through hooks: agent_end, after_compaction, before_reset.",
+					);
+				}
+			}
+			if (!cfg.sessionDigest) {
+				lines.push("Thread capture: disabled (sessionDigest=false)");
+			}
+
 			// 1. Mode + connection target
 			const remote = !isDefaultApiUrl(cfg.apiUrl);
 			const mode = remote ? "remote" : "local";
@@ -101,6 +147,8 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 				`Mode: ${remote ? `Remote (${cfg.apiUrl})` : "Local (127.0.0.1:14242)"}`,
 			);
 			lines.push(`API key: ${cfg.apiKey ? "set" : "not set"}`);
+			lines.push("Memory tools: nmem CLI");
+			lines.push("Thread sync: Mem HTTP API");
 
 			// 2. CLI resolution
 			try {
@@ -156,6 +204,9 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 				} else {
 					lines.push("  Ensure the Nowledge Mem desktop app is running.");
 				}
+				lines.push(
+					"  Memory tools may still work through the CLI, but thread auto-sync will fail while the HTTP API is unreachable.",
+				);
 			}
 
 			// 4. Effective config with sources
@@ -179,6 +230,9 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 			lines.push(
 				`  maxThreadMessageChars: ${cfg.maxThreadMessageChars} (${sources.maxThreadMessageChars || "?"})`,
 			);
+			lines.push(
+				`  corpusSupplement: ${cfg.corpusSupplement} (${sources.corpusSupplement || "?"})`,
+			);
 
 			details.config = {
 				sessionContext: {
@@ -205,6 +259,10 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 					value: cfg.maxThreadMessageChars,
 					source: sources.maxThreadMessageChars,
 				},
+				corpusSupplement: {
+					value: cfg.corpusSupplement,
+					source: sources.corpusSupplement,
+				},
 				apiUrl: { value: cfg.apiUrl || "(local)", source: sources.apiUrl },
 				apiKey: {
 					value: cfg.apiKey ? "(set)" : "(not set)",