@nowledge/openclaw-nowledge-mem 0.8.3 → 0.8.12

package/CHANGELOG.md

@@ -2,6 +2,88 @@
 
 All notable changes to the Nowledge Mem OpenClaw plugin will be documented in this file.
 
+## Unreleased
+
+### Fixed
+
+- OpenClaw now preserves an explicit empty `space` setting as a real choice to stay on `Default`, instead of silently falling through to ambient `NMEM_SPACE`.
+- CLI-backed OpenClaw operations now honor that same explicit Default-space choice. Earlier builds could still inherit `NMEM_SPACE` in child `nmem` processes, which split CLI-backed reads and writes away from HTTP-backed thread sync.
+- Fallback HTTP requests now carry the ambient lane through one shared path, so direct API calls stay aligned with CLI-backed memory operations.
+- `nowledge_mem_status` now reports the configured Context Engine slot correctly instead of reading from an unset field.
+- `nowledge_mem_status` now reports `legacy` when no Context Engine slot is configured, instead of surfacing `undefined` in default OpenClaw setups.
+- Legacy `~/.nowledge-mem/openclaw.json` now gets the same strict key validation as dashboard config, so typoed or unsupported keys fail loudly instead of silently altering runtime behavior.
+- Thread capture no longer fails at runtime after the thread-identity refactor. The crypto import used by external IDs and append idempotency keys is restored, so `sessionDigest` capture keeps creating and appending threads normally.
+
+### Changed
+
+- Lower-priority `spaceTemplate` values are now evaluated lazily. A broken template no longer overrides a higher-priority concrete `space` value.
+- Thread-identity tests now reset conversation-root state between cases, so the suite matches real runtime boundaries more closely.
+
+## [0.8.12] - 2026-04-10
+
+### Changed
+
+- OpenClaw's space settings and setup guidance now lead with profile-owned config (`space`, `spaceTemplate`) and keep `NMEM_SPACE` as a fallback for launcher-driven sessions without a richer config surface.
+
+## [0.8.11] - 2026-04-10
+
+### Added
+
+- OpenClaw profiles can now own one ambient space directly through plugin config `space` or `spaceTemplate`, instead of relying only on the process-wide `NMEM_SPACE` environment variable.
+
+### Changed
+
+- `nowledge_mem_status` now reports the effective ambient space and where it came from.
+
+## [0.8.10] - 2026-04-10
+
+### Changed
+
+- Clarified OpenClaw's ambient space model. `NMEM_SPACE` now remains the single session lane across CLI-backed memory calls and API-backed thread/feed fallbacks, while shared spaces, default retrieval, and agent guidance stay in Mem's shared `/spaces` profile.
+
+## [0.8.9] - 2026-04-10
+
+### Fixed
+
+- **`/new` once again starts a fresh Mem thread.** Thread identity now follows OpenClaw's session lifecycle instead of collapsing everything under the channel-level `sessionKey`. Explicit `/new`, `/reset`, idle rollovers, and daily rollovers create a new Mem thread as users expect.
+- **Compaction still stays inside the same Mem thread.** When OpenClaw rotates the underlying transcript during compaction, the plugin now carries the existing conversation root forward so compaction does not fork a second thread for the same chat.
+
+### Changed
+
+- **Capture now uses lifecycle-aware conversation roots.** `session_end` and `session_start` hooks teach the plugin when a new chat begins and when a transcript rotation is only internal maintenance. Context Engine capture and hook-based capture still converge on the same thread, but `/new` is no longer merged into the prior conversation.
+
+## [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

@@ -11,6 +11,7 @@ Continuation guide for `community/nowledge-mem-openclaw-plugin`.
 - 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.
+- 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.
 
 ## Design Philosophy
 
@@ -94,7 +95,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 |
@@ -165,6 +166,7 @@ When `contextEngine` points elsewhere (or is absent), hooks handle everything. N
 
 Plugin settings: OpenClaw dashboard (pluginConfig). Legacy `~/.nowledge-mem/openclaw.json` still honored.
 Credentials (apiUrl/apiKey): also reads `~/.nowledge-mem/config.json` (shared with all Nowledge Mem tools).
+Ambient space: choose one real lane through plugin config `space` or `spaceTemplate` first. Use `NMEM_SPACE` only as the fallback for launcher-driven sessions that already belong to one real lane. Do not introduce a second plugin-local vault concept. Legacy `NMEM_SPACE_ID` remains compatibility-only.
 
 | Key | Type | Default | Env Var | Description |
 |-----|------|---------|---------|-------------|
@@ -181,6 +183,8 @@ Credentials (apiUrl/apiKey): also reads `~/.nowledge-mem/config.json` (shared wi
 | `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. |
+| `space` | string | `""` | `NMEM_SPACE` (fallback only) | Fixed ambient space name for this OpenClaw profile or agent lane |
+| `spaceTemplate` | string | `""` | — | Template with `${ENV_VAR}` placeholders, used only when `space` is empty |
 
 **Priority** (plugin-specific keys): `openclaw.json` (legacy) > pluginConfig > env var > default.
 **Priority** (apiUrl/apiKey): `openclaw.json` (legacy) > pluginConfig > `config.json` (shared) > env var > default.

package/README.md

@@ -97,6 +97,31 @@ Legacy `~/.nowledge-mem/openclaw.json` is still honored first for backward compa
 
 The resolved `apiUrl` and `apiKey` are reused across the plugin: CLI-backed memory tools and API-backed thread sync both talk to the same backend. The `apiKey` is never passed as a CLI argument and is never logged.
 
+### Spaces
+
+Spaces are optional. OpenClaw should choose one ambient lane only when the profile or process already belongs to one real project or agent lane.
+
+The OpenClaw plugin settings can own that lane directly:
+
+```json
+{
+  "space": "Research Agent",
+  "spaceTemplate": "agent-${OPENCLAW_AGENT_NAME}"
+}
+```
+
+Use `space` when one OpenClaw profile belongs to one stable lane. Use `spaceTemplate` only when your launcher or host environment already sets a trustworthy variable that identifies the lane. If your OpenClaw runtime does not expose per-agent identity to plugins, do not fake it. Use one profile/process per lane or stay on `Default`.
+
+If you are running OpenClaw from a launcher or script with no richer config surface, you can still set one session-wide fallback lane with:
+
+```bash
+NMEM_SPACE="Research Agent"
+```
+
+Nowledge Mem's CLI-backed Working Memory, memory search/save, and the plugin's API-backed thread/feed fallbacks will then stay in that lane together. There is no second OpenClaw-only vault setting; the shared Mem boundary is still one hidden space key, but humans and agents should normally work with the space name instead.
+
+Shared spaces, default retrieval, and agent guidance still live in Mem's own space profile. OpenClaw chooses the lane and preserves it across transports; it should not duplicate the profile semantics.
+
 ### Configure via WebUI of OpenClaw
 
 <img width="1192" height="2007" alt="openclaw-config" src="https://github.com/user-attachments/assets/a4abd855-db56-4a1f-b0ac-0114909d0c20" />
@@ -365,7 +390,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. The boundary follows OpenClaw's own session lifecycle: one active chat becomes one Mem thread, `/new` or `/reset` starts a fresh thread, and internal compaction keeps appending to the same thread instead of forking a duplicate. Context Engine capture and hook-based capture still converge on 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 +433,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 +474,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 +530,43 @@ 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 active OpenClaw chat becomes one Mem thread
+- running `/new` or `/reset` starts a fresh Mem thread
+- compaction does not fork a second thread for the same chat
+- 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 +577,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/SKILL.md

@@ -63,6 +63,7 @@ Explain the difference plainly:
 
 - Local mode: OpenClaw talks to the local Nowledge Mem app/server through `nmem`
 - Remote mode: OpenClaw talks to a remote Nowledge Mem server through `nmem --api-url ...`; add `apiKey` when that server has auth enabled
+- If the user wants one agent-specific lane, use plugin config `space` first, plugin config `spaceTemplate` only when the launcher already exposes a trustworthy lane signal, and `NMEM_SPACE="<space name>"` only as the fallback for CLI-style launches instead of inventing a second OpenClaw-only memory namespace
 
 ### Step 1 — Verify `nmem`
 

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.12",
 	"kind": "memory",
 	"skills": [
 		"skills/memory-guide"
@@ -60,6 +60,14 @@
 			"label": "API key (remote mode)",
 			"help": "Required when connecting to a remote server. Never logged or passed as a CLI argument. Injected as NMEM_API_KEY env var only.",
 			"sensitive": true
+		},
+		"space": {
+			"label": "Ambient space",
+			"help": "Optional fixed space name for this OpenClaw profile or agent lane. Leave empty to stay on Default."
+		},
+		"spaceTemplate": {
+			"label": "Ambient space template",
+			"help": "Optional template with ${ENV_VAR} placeholders, used only when Ambient space is empty and your launcher already exports a trustworthy lane signal. Example: agent-${OPENCLAW_AGENT_NAME}."
 		}
 	},
 	"configSchema": {
@@ -144,6 +152,16 @@
 				"type": "string",
 				"default": "",
 				"description": "API key for remote access. Stored in plugin config, injected as NMEM_API_KEY env var. Never logged."
+			},
+			"space": {
+				"type": "string",
+				"default": "",
+				"description": "Optional fixed space name for this OpenClaw profile or agent lane."
+			},
+			"spaceTemplate": {
+				"type": "string",
+				"default": "",
+				"description": "Optional template with ${ENV_VAR} placeholders. Used only when space is empty."
 			}
 		}
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@nowledge/openclaw-nowledge-mem",
 	"displayName": "Nowledge Mem for OpenClaw",
-	"version": "0.8.3",
+	"version": "0.8.12",
 	"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"
@@ -43,13 +42,11 @@
 	},
 	"main": "src/index.js",
 	"scripts": {
+		"test": "node --test tests/*.test.mjs",
 		"validate": "node scripts/validate-plugin.mjs",
 		"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/client.js

@@ -70,7 +70,7 @@ export class NowledgeMemClient {
 	/**
 	 * @param {object} logger
 	 * @param {object} runtimeSystem
-	 * @param {{ apiUrl?: string; apiKey?: string }} [credentials]
+	 * @param {{ apiUrl?: string; apiKey?: string; space?: string; spaceId?: string }} [credentials]
 	 */
 	constructor(logger, runtimeSystem, credentials = {}) {
 		this.logger = logger;
@@ -82,6 +82,18 @@ export class NowledgeMemClient {
 			(credentials.apiUrl || "").trim() || "http://127.0.0.1:14242"
 		).replace(/\/+$/, "");
 		this._apiKey = (credentials.apiKey || "").trim();
+		const hasSpace = Object.prototype.hasOwnProperty.call(credentials, "space");
+		const hasSpaceId = Object.prototype.hasOwnProperty.call(
+			credentials,
+			"spaceId",
+		);
+		this._hasExplicitSpace = hasSpace || hasSpaceId;
+		const resolvedSpace = hasSpace
+			? credentials.space
+			: hasSpaceId
+				? credentials.spaceId
+				: process.env.NMEM_SPACE ?? process.env.NMEM_SPACE_ID ?? "";
+		this._spaceRef = String(resolvedSpace ?? "").trim();
 	}
 
 	// ── API helpers (fallback path and direct operations) ─────────────────────
@@ -99,15 +111,39 @@ export class NowledgeMemClient {
 		return headers;
 	}
 
+	_withSpaceQuery(path) {
+		if (!this._spaceRef) return path;
+		const [pathname, rawQuery = ""] = String(path).split("?", 2);
+		const query = new URLSearchParams(rawQuery);
+		if (!query.has("space_id")) {
+			query.set("space_id", this._spaceRef);
+		}
+		const rendered = query.toString();
+		return rendered ? `${pathname}?${rendered}` : pathname;
+	}
+
+	_withSpaceBody(body) {
+		if (!this._spaceRef || body == null || Array.isArray(body)) {
+			return body;
+		}
+		if (Object.prototype.hasOwnProperty.call(body, "space_id")) {
+			return body;
+		}
+		return { ...body, space_id: this._spaceRef };
+	}
+
 	async apiJson(method, path, body, timeout = 30_000) {
 		const controller = new AbortController();
 		const timer = setTimeout(() => controller.abort(), timeout);
-		const url = `${this.getApiBaseUrl()}${path}`;
+		const scopedPath = this._withSpaceQuery(path);
+		const scopedBody = this._withSpaceBody(body);
+		const url = `${this.getApiBaseUrl()}${scopedPath}`;
 		try {
 			const response = await fetch(url, {
 				method,
 				headers: this.getApiHeaders(),
-				body: body === undefined ? undefined : JSON.stringify(body),
+				body:
+					scopedBody === undefined ? undefined : JSON.stringify(scopedBody),
 				signal: controller.signal,
 			});
 
@@ -184,6 +220,8 @@ export class NowledgeMemClient {
 		return buildNmemSpawnEnv({
 			apiUrl: this._apiUrl,
 			apiKey: this._apiKey,
+			spaceId: this._spaceRef,
+			hasExplicitSpace: this._hasExplicitSpace,
 		});
 	}
 
@@ -557,12 +595,16 @@ export class NowledgeMemClient {
 			throw new Error("createThread requires at least one message");
 		}
 
-		const data = await this.apiJson("POST", "/threads", {
-			...(threadId ? { thread_id: String(threadId) } : {}),
-			title: normalizedTitle,
-			source: String(source),
-			messages,
-		});
+		const data = await this.apiJson(
+			"POST",
+			"/threads",
+			{
+				...(threadId ? { thread_id: String(threadId) } : {}),
+				title: normalizedTitle,
+				source: String(source),
+				messages,
+			},
+		);
 
 		return String(
 			data.id ?? data.thread?.thread_id ?? data.thread_id ?? "created",
@@ -692,7 +734,11 @@ export class NowledgeMemClient {
 			});
 			if (updated === null) throw new Error(`Section not found: ${heading}`);
 
-			return this.apiJson("PUT", "/agent/working-memory", { content: updated });
+			return this.apiJson(
+				"PUT",
+				"/agent/working-memory",
+				{ content: updated },
+			);
 		}
 	}
 

package/src/config.js

@@ -28,6 +28,8 @@ const ALLOWED_KEYS = new Set([
 	"corpusMinScore",
 	"apiUrl",
 	"apiKey",
+	"space",
+	"spaceTemplate",
 	// Legacy aliases — accepted but not advertised
 	"autoRecall",
 	"autoCapture",
@@ -128,6 +130,30 @@ function envInt(name) {
 	return Number.isFinite(n) ? n : undefined;
 }
 
+function pickStr(obj, key) {
+	if (typeof obj[key] !== "string") return undefined;
+	const trimmed = obj[key].trim();
+	return trimmed || undefined;
+}
+
+function pickPresentString(obj, key) {
+	if (!Object.prototype.hasOwnProperty.call(obj, key)) return undefined;
+	if (typeof obj[key] !== "string") return undefined;
+	return obj[key].trim();
+}
+
+function resolveEnvTemplate(value) {
+	return value.replace(/\$\{([^}]+)\}/g, (_, envVar) => {
+		const envValue = process.env[envVar];
+		if (typeof envValue !== "string" || !envValue.trim()) {
+			throw new Error(
+				`nowledge-mem: environment variable ${envVar} is required by spaceTemplate`,
+			);
+		}
+		return envValue.trim();
+	});
+}
+
 // --- helpers to read a boolean/number from resolved sources --------------
 
 function pickBool(obj, key) {
@@ -162,7 +188,8 @@ function resolveAliases(obj) {
  */
 function firstDefined(...options) {
 	for (const opt of options) {
-		if (opt.value !== undefined) return opt;
+		const value = typeof opt.resolve === "function" ? opt.resolve() : opt.value;
+		if (value !== undefined) return { ...opt, value };
 	}
 	return options[options.length - 1];
 }
@@ -185,7 +212,8 @@ function firstDefined(...options) {
  * but is no longer the recommended path.
  *
  * Canonical keys: sessionContext, sessionDigest, digestMinInterval,
- *                 maxContextResults, recallMinScore, maxThreadMessageChars, apiUrl, apiKey
+ *                 maxContextResults, recallMinScore, maxThreadMessageChars,
+ *                 apiUrl, apiKey, space, spaceTemplate
  *
  * Legacy aliases (accepted from all sources; never shown in docs):
  *   autoRecall → sessionContext
@@ -205,6 +233,7 @@ function firstDefined(...options) {
  *   NMEM_CORPUS_MIN_SCORE      — integer (0-100)
  *   NMEM_API_URL               — remote server URL
  *   NMEM_API_KEY               — API key (never logged)
+ *   NMEM_SPACE                 — ambient space name (legacy: NMEM_SPACE_ID)
  */
 export function parseConfig(raw, logger) {
 	const pluginCfg = raw && typeof raw === "object" ? raw : {};
@@ -215,16 +244,19 @@ export function parseConfig(raw, logger) {
 	const resolvedPlugin = resolveAliases(pluginCfg);
 	const resolvedFile = resolveAliases(fileCfg);
 
-	// Strict: reject unknown keys in pluginConfig (typo catcher).
-	const unknownKeys = Object.keys(resolvedPlugin).filter(
-		(k) => !ALLOWED_KEYS.has(k),
-	);
-	if (unknownKeys.length > 0) {
-		throw new Error(
-			`nowledge-mem: unknown config key${unknownKeys.length > 1 ? "s" : ""}: ${unknownKeys.join(", ")}. ` +
-				`Allowed keys: ${[...ALLOWED_KEYS].filter((k) => !Object.keys(ALIAS_KEYS).includes(k)).join(", ")}`,
-		);
-	}
+	const validateKnownKeys = (obj, sourceLabel) => {
+		const unknownKeys = Object.keys(obj).filter((k) => !ALLOWED_KEYS.has(k));
+		if (unknownKeys.length > 0) {
+			throw new Error(
+				`nowledge-mem: unknown config key${unknownKeys.length > 1 ? "s" : ""} in ${sourceLabel}: ${unknownKeys.join(", ")}. ` +
+					`Allowed keys: ${[...ALLOWED_KEYS].filter((k) => !Object.keys(ALIAS_KEYS).includes(k)).join(", ")}`,
+			);
+		}
+	};
+
+	// Strict: reject unknown keys in both legacy file config and dashboard config.
+	validateKnownKeys(resolvedFile, "~/.nowledge-mem/openclaw.json");
+	validateKnownKeys(resolvedPlugin, "plugin config");
 
 	const _sources = {};
 
@@ -351,6 +383,31 @@ export function parseConfig(raw, logger) {
 	const apiKey = ak.value;
 	_sources.apiKey = ak.source;
 
+	// --- space: file (legacy) > pluginConfig > template > env > default ---
+	const fs = pickPresentString(resolvedFile, "space");
+	const ps = pickPresentString(resolvedPlugin, "space");
+	const fst = pickStr(resolvedFile, "spaceTemplate");
+	const pst = pickStr(resolvedPlugin, "spaceTemplate");
+	const spaceChoice = firstDefined(
+		{ value: fs, source: "file" },
+		{ value: ps, source: "pluginConfig" },
+		{
+			resolve: () => (fst ? resolveEnvTemplate(fst) : undefined),
+			source: "file:template",
+		},
+		{
+			resolve: () => (pst ? resolveEnvTemplate(pst) : undefined),
+			source: "pluginConfig:template",
+		},
+		{
+			value: envStr("NMEM_SPACE") ?? envStr("NMEM_SPACE_ID"),
+			source: "env",
+		},
+		{ value: "", source: "default" },
+	);
+	const space = spaceChoice.value || "";
+	_sources.space = spaceChoice.source;
+
 	// --- corpusSupplement: file > pluginConfig > env > default ---
 	const cs = firstDefined(
 		{ value: pickBool(resolvedFile, "corpusSupplement"), source: "file" },
@@ -445,6 +502,7 @@ export function parseConfig(raw, logger) {
 		corpusMinScore,
 		apiUrl,
 		apiKey,
+		space,
 		_sources,
 	};
 }

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,26 @@
-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 { createHash } from "node:crypto";
+import { isCronSessionKey, isSubagentSessionKey } from "openclaw/plugin-sdk/routing";
+import {
+	buildStableThreadId,
+} from "./thread-identity.js";
+export {
+	_resetConversationRoots,
+	buildStableThreadId,
+	registerSessionEndConversation,
+	registerSessionStartConversation,
+} from "./thread-identity.js";
 
 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.
@@ -15,7 +29,6 @@ const _lastCaptureAt = new Map();
 const _MAX_COOLDOWN_ENTRIES = 200;
 const _syncedMessageCounts = new Map();
 const _MAX_SYNC_CURSOR_ENTRIES = 500;
-
 function _setLastCapture(threadId, now) {
 	_lastCaptureAt.set(threadId, now);
 	// Opportunistic eviction: sweep stale entries when map grows large
@@ -113,6 +126,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 +210,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 +249,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) {
@@ -199,17 +263,6 @@ function sanitizeIdPart(input, max = 48) {
 	return normalized.slice(0, max);
 }
 
-export function buildStableThreadId(event, ctx) {
-	const base =
-		String(ctx?.sessionId || "").trim() ||
-		String(ctx?.sessionKey || "").trim() ||
-		String(event?.sessionFile || "").trim() ||
-		"session";
-	const slug = sanitizeIdPart(base);
-	const digest = createHash("sha1").update(base).digest("hex").slice(0, 10);
-	return `openclaw-${slug}-${digest}`;
-}
-
 function buildExternalId({ normalized, index, threadId, sessionKey }) {
 	if (normalized.externalHint) {
 		return `oc:${sanitizeIdPart(normalized.externalHint, 96)}`;
@@ -282,7 +335,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 +510,7 @@ export async function triageAndDistill({
 
 		const distillResult = await client.distillThread({
 			threadId: captureResult.threadId,
-			title: buildThreadTitle(ctx, "distilled"),
+			title: buildThreadTitle(ctx),
 			content: conversationText,
 		});
 
@@ -477,8 +530,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 +541,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 +549,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 +587,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 +601,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/hooks/thread-identity.js

@@ -0,0 +1,129 @@
+import { createHash } from "node:crypto";
+
+const _conversationRootsBySessionId = new Map();
+const _activeConversationRootsBySessionKey = new Map();
+const _MAX_CONVERSATION_ROOT_ENTRIES = 500;
+
+function sanitizeIdPart(input, max = 48) {
+	const normalized = String(input || "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "");
+	if (!normalized) return "session";
+	return normalized.slice(0, max);
+}
+
+function _setConversationRoot({ sessionId, sessionKey, rootId }) {
+	const normalizedRoot = String(rootId || "").trim();
+	if (!normalizedRoot) return;
+	const normalizedSessionId = String(sessionId || "").trim();
+	const normalizedSessionKey = String(sessionKey || "").trim();
+
+	if (normalizedSessionId) {
+		_conversationRootsBySessionId.set(normalizedSessionId, normalizedRoot);
+		if (_conversationRootsBySessionId.size > _MAX_CONVERSATION_ROOT_ENTRIES) {
+			const excess =
+				_conversationRootsBySessionId.size - _MAX_CONVERSATION_ROOT_ENTRIES;
+			let removed = 0;
+			for (const key of _conversationRootsBySessionId.keys()) {
+				_conversationRootsBySessionId.delete(key);
+				removed += 1;
+				if (removed >= excess) break;
+			}
+		}
+	}
+
+	if (normalizedSessionKey) {
+		_activeConversationRootsBySessionKey.set(
+			normalizedSessionKey,
+			normalizedRoot,
+		);
+		if (
+			_activeConversationRootsBySessionKey.size > _MAX_CONVERSATION_ROOT_ENTRIES
+		) {
+			const excess =
+				_activeConversationRootsBySessionKey.size - _MAX_CONVERSATION_ROOT_ENTRIES;
+			let removed = 0;
+			for (const key of _activeConversationRootsBySessionKey.keys()) {
+				_activeConversationRootsBySessionKey.delete(key);
+				removed += 1;
+				if (removed >= excess) break;
+			}
+		}
+	}
+}
+
+export function resolveConversationRoot(event, ctx) {
+	const sessionId = String(ctx?.sessionId || event?.sessionId || "").trim();
+	if (sessionId) {
+		const mappedRoot = _conversationRootsBySessionId.get(sessionId);
+		if (mappedRoot) return mappedRoot;
+	}
+
+	const sessionKey = String(ctx?.sessionKey || event?.sessionKey || "").trim();
+	if (sessionKey) {
+		const activeRoot = _activeConversationRootsBySessionKey.get(sessionKey);
+		if (activeRoot) return activeRoot;
+	}
+
+	return (
+		sessionId ||
+		sessionKey ||
+		String(event?.sessionFile || "").trim() ||
+		"session"
+	);
+}
+
+export function registerSessionStartConversation(event, ctx) {
+	const sessionId = String(event?.sessionId || ctx?.sessionId || "").trim();
+	const sessionKey = String(event?.sessionKey || ctx?.sessionKey || "").trim();
+	if (!sessionId && !sessionKey) return;
+
+	const resumedFrom = String(event?.resumedFrom || "").trim();
+	const inheritedRoot =
+		_conversationRootsBySessionId.get(sessionId) ||
+		(resumedFrom && _conversationRootsBySessionId.get(resumedFrom)) ||
+		sessionId;
+
+	_setConversationRoot({
+		sessionId,
+		sessionKey,
+		rootId: inheritedRoot || sessionId || sessionKey,
+	});
+}
+
+export function registerSessionEndConversation(event, ctx) {
+	const sessionId = String(event?.sessionId || ctx?.sessionId || "").trim();
+	const sessionKey = String(event?.sessionKey || ctx?.sessionKey || "").trim();
+	if (!sessionId && !sessionKey) return;
+
+	const currentRoot = resolveConversationRoot(event, ctx);
+	_setConversationRoot({
+		sessionId,
+		sessionKey,
+		rootId: currentRoot,
+	});
+
+	const nextSessionId = String(event?.nextSessionId || "").trim();
+	if (!nextSessionId) return;
+
+	const reason = String(event?.reason || "").trim().toLowerCase();
+	const nextRoot = reason === "compaction" ? currentRoot : nextSessionId;
+	_setConversationRoot({
+		sessionId: nextSessionId,
+		sessionKey,
+		rootId: nextRoot,
+	});
+}
+
+export function buildStableThreadId(event, ctx) {
+	const base = resolveConversationRoot(event, ctx);
+	const slug = sanitizeIdPart(base);
+	const digest = createHash("sha1").update(base).digest("hex").slice(0, 10);
+	return `openclaw-${slug}-${digest}`;
+}
+
+export function _resetConversationRoots() {
+	_conversationRootsBySessionId.clear();
+	_activeConversationRootsBySessionKey.clear();
+}

package/src/index.js

@@ -12,6 +12,8 @@ import { buildBehavioralHook } from "./hooks/behavioral.js";
 import {
 	buildAgentEndCaptureHandler,
 	buildBeforeResetCaptureHandler,
+	registerSessionEndConversation,
+	registerSessionStartConversation,
 } from "./hooks/capture.js";
 import { buildRecallHandler } from "./hooks/recall.js";
 import { createConnectionsTool } from "./tools/connections.js";
@@ -38,6 +40,7 @@ export default {
 		const client = new NowledgeMemClient(logger, api.runtime.system, {
 			apiUrl: cfg.apiUrl,
 			apiKey: cfg.apiKey,
+			space: cfg.space,
 		});
 
 		// OpenClaw memory-slot compatibility (required for system prompt activation)
@@ -57,30 +60,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 +118,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.
@@ -123,6 +140,8 @@ export default {
 				cfg,
 				logger,
 			);
+			api.on("session_start", registerSessionStartConversation);
+			api.on("session_end", registerSessionEndConversation);
 			api.on("agent_end", buildAgentEndCaptureHandler(client, cfg, logger));
 			api.on("after_compaction", (event, ctx) =>
 				threadCaptureHandler({ ...event, reason: "compaction" }, ctx),

package/src/spawn-env.js

@@ -3,17 +3,31 @@ const LOCAL_API_URL = "http://127.0.0.1:14242";
 /**
  * Build the child env for nmem CLI execution.
  * apiKey stays in env only and is never passed as a CLI flag.
- * Clear inherited NMEM_* values first so the resolved plugin config wins.
+ * Clear inherited API endpoint/auth values first so the resolved plugin config wins.
+ * Keep the ambient space lane unless an explicit override is provided. Prefer
+ * NMEM_SPACE for the human-facing contract, while preserving legacy
+ * NMEM_SPACE_ID for older setups. An explicit empty override means "stay on
+ * Default", so inherited ambient space vars must be cleared too.
  */
-export function buildNmemSpawnEnv({ apiUrl, apiKey } = {}) {
+export function buildNmemSpawnEnv(
+	{ apiUrl, apiKey, spaceId, hasExplicitSpace = false } = {},
+) {
 	const env = { ...process.env };
 	delete env.NMEM_API_URL;
 	delete env.NMEM_API_KEY;
+	if (hasExplicitSpace) {
+		delete env.NMEM_SPACE;
+		delete env.NMEM_SPACE_ID;
+	}
 	if (apiUrl && apiUrl !== LOCAL_API_URL) {
 		env.NMEM_API_URL = apiUrl;
 	}
 	if (apiKey) {
 		env.NMEM_API_KEY = apiKey;
 	}
+	if (hasExplicitSpace && typeof spaceId === "string" && spaceId.length > 0) {
+		env.NMEM_SPACE = spaceId;
+		env.NMEM_SPACE_ID = spaceId;
+	}
 	return env;
 }

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;
-			details.memorySlot = memorySlot ?? "(unknown)";
+			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;
 			if (memorySlot && memorySlot !== "openclaw-nowledge-mem") {
 				const corpusOn = cfg.corpusSupplement === true;
 				if (corpusOn) {
@@ -90,17 +103,61 @@ 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)");
+			} else {
+				lines.push(
+					"  Thread identity follows OpenClaw session lifecycle: /new or /reset starts a fresh thread, while compaction stays in the same thread.",
+				);
+			}
+
 			// 1. Mode + connection target
 			const remote = !isDefaultApiUrl(cfg.apiUrl);
 			const mode = remote ? "remote" : "local";
 			details.mode = mode;
 			details.apiUrl = cfg.apiUrl || "http://127.0.0.1:14242";
 			details.apiKeySet = Boolean(cfg.apiKey);
+			details.space = cfg.space || null;
+			details.spaceSource = sources.space || "default";
 
 			lines.push(
 				`Mode: ${remote ? `Remote (${cfg.apiUrl})` : "Local (127.0.0.1:14242)"}`,
 			);
 			lines.push(`API key: ${cfg.apiKey ? "set" : "not set"}`);
+			lines.push(
+				`Ambient space: ${cfg.space ? `${cfg.space} (${details.spaceSource})` : "Default"}`,
+			);
+			lines.push("Memory tools: nmem CLI");
+			lines.push("Thread sync: Mem HTTP API");
 
 			// 2. CLI resolution
 			try {
@@ -156,6 +213,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 +239,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 +268,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)",