@nowledge/openclaw-nowledge-mem 0.8.23 → 0.8.25

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to the Nowledge Mem OpenClaw plugin will be documented in th
 
 ## Unreleased
 
+## [0.8.25] - 2026-06-06
+
+### Improved
+
+- `nowledge_mem_context`, `sessionContext`, and Context Engine prompt injection now load Context Bundle when available, then fall back to Working Memory for older `nmem` clients. OpenClaw can receive owner identity, AI Identity, active space, active rules, and current priorities through the existing context surface without a tool-name change.
+
+## [0.8.24] - 2026-05-15
+
+### Fixed
+
+- OpenClaw session capture now handles newer per-turn `agent_end` hook payloads from Codex app-server runtimes. The plugin no longer mistakes those shorter batches for transcript compaction, so continued turns keep syncing into the same Mem thread after an OpenClaw upgrade.
+- Captured Codex app-server messages now use OpenClaw's stable mirror identity for Mem-side dedupe, keeping Context Engine `afterTurn` and hook backstop capture idempotent when both paths see the same turn.
+- Capture setup no longer depends on runtime-only OpenClaw SDK imports, keeping the plugin loadable on existing OpenClaw installer builds while still matching the host session-key contract.
+
 ## [0.8.23] - 2026-05-02
 
 ### Fixed

package/CLAUDE.md

@@ -44,7 +44,7 @@ src/
     memory-search.js    - OpenClaw compat; multi-signal; bi-temporal; relevance_reason; sourceThreadId
     memory-get.js       - OpenClaw compat; supports MEMORY.md alias; sourceThreadId
     save.js             - structured capture: unit_type, labels, temporal, importance; pre-save dedup check
-    context.js          - Working Memory daily briefing (read + section-level patch)
+    context.js          - startup context read + Working Memory section-level patch
     connections.js      - graph exploration: edge types, relationship strength, provenance
     timeline.js         - activity feed: daily grouping, event_type filter, memoryId hints
     forget.js           - memory deletion by ID or search
@@ -66,7 +66,7 @@ When `corpusSupplement: true`, the plugin registers a `MemoryCorpusSupplement` v
 
 1. **Recall**: When memory-core's `memory_search` runs, it fans out to all registered corpus supplements. Our supplement calls `client.search()` and maps results to `MemoryCorpusSearchResult` format.
 2. **Dreaming**: Recalled Nowledge Mem content accumulates frequency, relevance, and diversity scores in memory-core's short-term recall store. High-scoring content is promoted to `MEMORY.md` during deep-phase dreaming.
-3. **Dedup**: When active, the recall hook and CE `assemble()` skip their own search-based recall (memories section only). Working Memory injection continues as before.
+3. **Dedup**: When active, the recall hook and CE `assemble()` skip their own search-based recall (memories section only). Startup context injection continues as before.
 
 ### When to enable
 
@@ -132,7 +132,7 @@ When `contextEngine` points elsewhere (or is absent), hooks handle everything. N
 
 ### Nowledge Mem Native (differentiators)
 - `nowledge_mem_save` - structured capture: `unit_type`, `labels[]`, `event_start`, `event_end`, `temporal_context`, `importance`. All fields wired to CLI and API.
-- `nowledge_mem_context` - Working Memory daily briefing. Read-only by default; supports section-level patch via `patch_section` + `patch_content`/`patch_append` params (uses `nmem wm patch` client-side read-modify-write).
+- `nowledge_mem_context` - startup context. Read-only by default: Context Bundle when available, Working Memory fallback on older `nmem` clients. Also supports Working Memory section-level patch via `patch_section` + `patch_content`/`patch_append` params (uses `nmem wm patch` client-side read-modify-write).
 - `nowledge_mem_connections` - graph exploration. Edges JOIN-ed to nodes by type: CRYSTALLIZED_FROM (crystal → source memories), EVOLVES (with sub-relations: supersedes/enriches/confirms/challenges), SOURCED_FROM (document provenance), MENTIONS (entities). Each connection shows strength % and memoryId.
 - `nowledge_mem_timeline` - activity feed via `nmem f`. Groups by day. `event_type` filter. Exact date range via `date_from`/`date_to` (YYYY-MM-DD). Entries include `(id: <memoryId>)` for chaining to connections.
 - `nowledge_mem_forget` - delete by ID or fuzzy query.
@@ -151,7 +151,7 @@ When `contextEngine` points elsewhere (or is absent), hooks handle everything. N
 ## Hook Surface
 
 - `before_prompt_build` (always-on) - directive behavioral guidance in system-prompt space: tells agent to search before answering questions about prior work/decisions/preferences, and to save decisions/learnings proactively. Explicitly notes semantic search (not file paths) to counter OpenClaw's hardcoded memory section. Adjusts when sessionContext is on to avoid redundant searches.
-- `before_prompt_build` (sessionContext) - session context: Working Memory + `searchRich()` memories with `relevanceReason`. Note: does NOT inject thread snippets — threads are available via `memory_search` tool and `nowledge_mem_thread_fetch`.
+- `before_prompt_build` (sessionContext) - session context: Context Bundle / Working Memory + `searchRich()` memories with `relevanceReason`. Note: does NOT inject thread snippets — threads are available via `memory_search` tool and `nowledge_mem_thread_fetch`.
 - `agent_end` - thread capture + LLM triage/distillation (requires `sessionDigest: true`)
 - `after_compaction` - thread append
 - `before_reset` - thread append
@@ -170,7 +170,7 @@ Ambient space: choose one real lane through plugin config `space` or `spaceTempl
 
 | Key | Type | Default | Env Var | Description |
 |-----|------|---------|---------|-------------|
-| `sessionContext` | boolean | `false` | `NMEM_SESSION_CONTEXT` | Inject Working Memory + relevant memories at prompt time |
+| `sessionContext` | boolean | `false` | `NMEM_SESSION_CONTEXT` | Inject Context Bundle / Working Memory + relevant memories at prompt time |
 | `sessionDigest` | boolean | `true` | `NMEM_SESSION_DIGEST` | Thread capture + LLM distillation at session end |
 | `digestMinInterval` | integer 0-86400 | `300` | `NMEM_DIGEST_MIN_INTERVAL` | Minimum seconds between session digests |
 | `maxContextResults` | integer 1-20 | `5` | `NMEM_MAX_CONTEXT_RESULTS` | How many memories to inject at prompt time |

package/README.md

@@ -83,7 +83,7 @@ If you manage config manually, or you want to verify what the installer selected
 }
 ```
 
-By default the agent gets 10 tools on demand, a behavioral skill that teaches it when to search and save, a short always-on system hint, and end-of-session capture. Working Memory injection is optional and controlled by `sessionContext`.
+By default the agent gets 10 tools on demand, a behavioral skill that teaches it when to search and save, a short always-on system hint, and end-of-session capture. Context Bundle / Working Memory injection is optional and controlled by `sessionContext`.
 
 ### Remote mode
 
@@ -117,7 +117,7 @@ The OpenClaw plugin settings can own that lane directly:
 }
 ```
 
-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`.
+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-AI 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:
 
@@ -127,6 +127,8 @@ 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.
 
+For multi-agent orchestrators, set `NMEM_AGENT_ID=<agent-slug>` per spawned OpenClaw worker. Add `NMEM_SPACE` only when that run should override the AI Identity's default space. `NMEM_HOST_AGENT_ID` is for advanced host-id aliases. Context Bundle will use the stable identity while keeping `source_app=openclaw` for provenance. Keep these as launcher environment variables instead of plugin config keys so OpenClaw's strict config validation remains stable.
+
 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
@@ -145,7 +147,7 @@ flowchart TD
     A["User sends message"] --> B["before_prompt_build hook"]
 
     B --> C["Behavioral guidance(cacheable system hint)"]
-    B -.->|"sessionContext: true"| D["Working Memory +relevant memories (~1-2 KB)"]
+    B -.->|"sessionContext: true"| D["Context Bundle / Working Memory +relevant memories (~1-2 KB)"]
 
     C --> E["Agent processes message(10 tools available)"]
     D --> E
@@ -172,7 +174,7 @@ The behavioral skill and always-on hook nudge the agent to **search before answe
 | Decision made, insight learned | `nowledge_mem_save` | Structured save with `unit_type`, `labels`, `event_start`, `importance`. |
 | "What was I doing last week?" | `nowledge_mem_timeline` | Activity feed grouped by day. Supports exact date ranges. |
 | "How is X connected to Y?" | `nowledge_mem_connections` | Graph walk: edges, entities, EVOLVES chains, document provenance. |
-| Need today's focus/priorities | `nowledge_mem_context` | Read Working Memory daily briefing. Supports section-level patch. |
+| Need startup context or today's focus/priorities | `nowledge_mem_context` | Read Context Bundle when available, with Working Memory fallback. Supports Working Memory section-level patch. |
 | Memory has `sourceThreadId` | `nowledge_mem_thread_fetch` | Fetch full source conversation. Pagination via `offset` + `limit`. |
 | "Find our discussion about X" | `nowledge_mem_thread_search` | Search past conversations by keyword. Returns matched snippets. |
 | "Forget X" | `nowledge_mem_forget` | Delete by ID or search query. |
@@ -241,7 +243,7 @@ When OpenClaw's memory-core is the primary memory slot and Nowledge Mem runs alo
 - Every time memory-core runs `memory_search`, it also searches Nowledge Mem's knowledge graph via the supplement.
 - Recalled Nowledge Mem content accumulates frequency and relevance scores in memory-core's short-term store.
 - High-scoring content is promoted to `MEMORY.md` during deep-phase dreaming (daily, 3 AM).
-- The plugin's own search-based recall is automatically disabled to avoid duplicates. Working Memory injection continues as before.
+- The plugin's own search-based recall is automatically disabled to avoid duplicates. Startup context injection continues as before.
 
 **When to enable:** When memory-core is the memory slot and you want your cross-tool knowledge graph to participate in OpenClaw's native dreaming cycle. Most users have Nowledge Mem as the memory slot directly, so this defaults to `false`.
 
@@ -306,7 +308,7 @@ temporal_context: past
 
 Eight memory types: `fact`, `preference`, `decision`, `plan`, `procedure`, `learning`, `context`, `event`. Each becomes a typed node in the knowledge graph. Labels enable filtering in `memory_search`. `event_start` records *when* something happened, not just when you saved it, powering bi-temporal search.
 
-**nowledge_mem_context** - Read today's Working Memory: focus areas, priorities, unresolved flags, and recent activity. Generated by the Knowledge Agent each morning, updated throughout the day.
+**nowledge_mem_context** - Read startup context. On current Nowledge Mem installs this is Context Bundle: owner identity, AI Identity, active space, active rules, Working Memory, and KFS paths. Older `nmem` clients fall back to today's Working Memory. Patch mode still edits Working Memory sections.
 
 **nowledge_mem_connections** - Explore the knowledge graph around a topic or memory. Returns connected memories, EVOLVES version chains (how understanding has grown), related entities, and source document provenance (which files or URLs knowledge was extracted from).
 
@@ -360,7 +362,7 @@ The plugin supports three modes. Choose based on how much you want to guarantee
 | Mode | Config | Behavior | Tradeoff |
 |------|--------|----------|----------|
 | **Default** (recommended) | `sessionContext: false, sessionDigest: true` | Agent calls 10 tools on demand. A short system hint stays on. Conversations captured + distilled at session end. | Lowest overhead. Agent decides when to search, usually smart, occasionally forgets. |
-| **Session context** | `sessionContext: true` | Working Memory + relevant memories injected at prompt time, plus all 10 tools still available. | Higher per-turn context cost. Guarantees context is present from the first turn. |
+| **Session context** | `sessionContext: true` | Context Bundle / Working Memory + relevant memories injected at prompt time, plus all 10 tools still available. | Higher per-turn context cost. Guarantees context is present from the first turn. |
 | **Minimal** | `sessionDigest: false` | Tool-only, no automatic capture. | Small overhead from the always-on hint only. Use when you handle memory manually. |
 
 **Which mode should you use?**
@@ -438,7 +440,7 @@ OpenClaw does not currently have a separate user-owned instruction file in this
 
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
-| `sessionContext` | boolean | `false` | Inject Working Memory + relevant memories at prompt time |
+| `sessionContext` | boolean | `false` | Inject Context Bundle / Working Memory + relevant memories at prompt time |
 | `sessionDigest` | boolean | `true` | Thread capture + LLM distillation at session end |
 | `digestMinInterval` | integer | `300` | Minimum seconds between session digests for the same thread (0-86400) |
 | `maxContextResults` | integer | `5` | Max memories to inject at prompt time (1-20, only used when sessionContext is enabled) |

package/SKILL.md

@@ -74,7 +74,7 @@ nmem --version
 If this fails:
 
 - For users with the desktop app, direct them to **Settings > Preferences > Developer Tools > Install CLI**
-- Otherwise suggest `pip install nmem-cli`
+- Otherwise suggest `pip install nmem-cli`, or on Arch Linux `yay -S nmem-cli` / `paru -S nmem-cli`
 
 ### Step 2 — Verify the Backend Before Plugin Setup
 

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
 	"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.23",
+	"description": "Cross-tool knowledge graph memory for OpenClaw with startup context, graph search, and session distillation.",
+	"version": "0.8.25",
 	"kind": ["memory", "context-engine"],
 	"skills": [
 		"skills/memory-guide"
@@ -10,7 +10,7 @@
 	"uiHints": {
 		"sessionContext": {
 			"label": "Session context injection",
-			"help": "Inject Working Memory and relevant memories at prompt time. Off by default; the agent can call memory_search on demand instead."
+			"help": "Inject Context Bundle / Working Memory and relevant memories at prompt time. Off by default; the agent can call memory_search on demand instead."
 		},
 		"sessionDigest": {
 			"label": "Session digest at end",
@@ -42,7 +42,7 @@
 		},
 		"corpusSupplement": {
 			"label": "Register as corpus supplement",
-			"help": "Make Nowledge Mem searchable through memory-core's recall pipeline and dreaming promotion. Enable when memory-core is your memory slot and you want cross-tool knowledge to participate in OpenClaw's native recall and dreaming. When enabled, the plugin's own search-based recall is skipped to avoid duplicates (Working Memory injection continues)."
+			"help": "Make Nowledge Mem searchable through memory-core's recall pipeline and dreaming promotion. Enable when memory-core is your memory slot and you want cross-tool knowledge to participate in OpenClaw's native recall and dreaming. When enabled, the plugin's own search-based recall is skipped to avoid duplicates (startup context injection continues)."
 		},
 		"corpusMaxResults": {
 			"label": "Corpus supplement max results",
@@ -80,7 +80,7 @@
 			"sessionContext": {
 				"type": "boolean",
 				"default": false,
-				"description": "Inject Working Memory and recalled memories at prompt time. Off by default; the agent queries memory on demand via tools."
+				"description": "Inject Context Bundle / Working Memory and recalled memories at prompt time. Off by default; the agent queries memory on demand via tools."
 			},
 			"sessionDigest": {
 				"type": "boolean",

package/package.json

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

package/skills/memory-guide/SKILL.md

@@ -31,7 +31,7 @@ Bi-temporal filters narrow results by time:
 
 ## Save (nowledge_mem_save)
 
-Save proactively when the conversation produces a decision, preference, plan, procedure, learning, or important context. Do not wait to be asked.
+Save proactively when the conversation produces a durable fact, preference, decision, plan, procedure, learning, event, or important context. Do not wait to be asked.
 
 Structure saves:
 
@@ -54,9 +54,9 @@ Browse recent activity grouped by day. Filter by `event_type` or exact `date_fro
 
 Find past conversations by keyword, then progressively fetch messages. Threads span all sources: this tool, other AI tools, browser capture, imports.
 
-## Working Memory (nowledge_mem_context)
+## Startup Context (nowledge_mem_context)
 
-Read the user's daily briefing (priorities, active projects, flags). Patch a specific section with `patch_section` + `patch_content`/`patch_append` when the conversation updates a priority or resolves a flag.
+Read Context Bundle when identity, active space, active rules, or current priorities matter. Older `nmem` clients fall back to the user's Working Memory briefing. Patch a specific Working Memory section with `patch_section` + `patch_content`/`patch_append` when the conversation updates a priority or resolves a flag.
 
 ## Important
 

package/src/client.js

@@ -690,12 +690,42 @@ export class NowledgeMemClient {
 			const data = await this.execJson(["--json", "wm", "read"], 15_000);
 			const content = String(data.content ?? "").trim();
 			const exists = Boolean(data.exists);
-			return { content, available: exists && content.length > 0 };
+			return {
+				content,
+				available: exists && content.length > 0,
+				source: "working-memory",
+			};
 		} catch {
-			return { content: "", available: false };
+			return { content: "", available: false, source: "working-memory" };
 		}
 	}
 
+	async readContextBundle() {
+		try {
+			const data = await this.execJson(
+				["--json", "context", "--source-app", "openclaw"],
+				15_000,
+			);
+			const content = String(
+				data.rendered_markdown ?? data.markdown ?? data.content ?? "",
+			).trim();
+			return {
+				content,
+				available: content.length > 0,
+				source: "context-bundle",
+				raw: data,
+			};
+		} catch {
+			return { content: "", available: false, source: "context-bundle" };
+		}
+	}
+
+	async readStartupContext() {
+		const bundle = await this.readContextBundle();
+		if (bundle.available) return bundle;
+		return this.readWorkingMemory();
+	}
+
 	/**
 	 * Patch a single section of Working Memory without touching the rest.
 	 * Uses `nmem wm patch` (CLI v0.4.1+) — client-side read-modify-write.

package/src/context-engine.js

@@ -183,24 +183,24 @@ export function createNowledgeMemContextEngineFactory(
 			info: {
 				id: "nowledge-mem",
 				name: "Nowledge Mem",
-				version: "0.8.0",
+				version: "0.8.25",
 				ownsCompaction: false,
 			},
 
 			// ------------------------------------------------------------------
-			// bootstrap — pre-warm Working Memory for first assemble()
+			// bootstrap — pre-warm startup context for first assemble()
 			// ------------------------------------------------------------------
 			async bootstrap({ sessionId, sessionKey }) {
 				const key = sessionKey || sessionId;
 				try {
-					const wm = await client.readWorkingMemory();
+					const wm = await client.readStartupContext();
 					const state = getSessionState(key);
 					state.wm = wm;
 					state.lastWmFetch = Date.now();
-					logger.debug?.(`ce: bootstrap — WM loaded for ${key}`);
+					logger.debug?.(`ce: bootstrap — startup context loaded for ${key}`);
 					return { bootstrapped: true };
 				} catch (err) {
-					logger.warn(`ce: bootstrap — WM read failed: ${err}`);
+					logger.warn(`ce: bootstrap — startup context read failed: ${err}`);
 					return { bootstrapped: false, reason: String(err) };
 				}
 			},
@@ -232,19 +232,23 @@ export function createNowledgeMemContextEngineFactory(
 					cfg.sessionContext ? SESSION_CONTEXT_GUIDANCE : BASE_GUIDANCE,
 				);
 
-				// 2. Working Memory (refresh if stale)
+				// 2. Startup context (refresh if stale)
 				try {
 					if (!state.wm || Date.now() - state.lastWmFetch > WM_CACHE_TTL_MS) {
-						state.wm = await client.readWorkingMemory();
+						state.wm = await client.readStartupContext();
 						state.lastWmFetch = Date.now();
 					}
 					if (state.wm?.available) {
+						const tag =
+							state.wm.source === "context-bundle"
+								? "nowledge-context-bundle"
+								: "working-memory";
 						sections.push(
-							`<working-memory>\n${escapeForPrompt(state.wm.content)}\n</working-memory>`,
+							`<${tag}>\n${escapeForPrompt(state.wm.content)}\n</${tag}>`,
 						);
 					}
 				} catch (err) {
-					logger.debug?.(`ce: assemble — WM read failed: ${err}`);
+					logger.debug?.(`ce: assemble — startup context read failed: ${err}`);
 				}
 
 				// 3. Recalled memories (when sessionContext enabled)

package/src/corpus-supplement.js

@@ -10,7 +10,7 @@
  * Enable via config: `corpusSupplement: true`
  *
  * Designed to coexist with the plugin's own tools and hooks:
- * - Working Memory injection: still handled by the recall hook / CE (only we know about WM)
+ * - Startup context injection: still handled by the recall hook / CE
  * - Search-based recall: handled by this supplement when active, by hooks/CE when not
  *
  * Error handling: both search() and get() catch all errors and return [] / null.

package/src/hooks/capture.js

@@ -1,9 +1,6 @@
-import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { isCronSessionKey, isSubagentSessionKey } from "openclaw/plugin-sdk/routing";
-import {
-	buildStableThreadId,
-} from "./thread-identity.js";
+import { readFile } from "node:fs/promises";
+import { buildStableThreadId } from "./thread-identity.js";
 export {
 	_resetConversationRoots,
 	buildStableThreadId,
@@ -29,6 +26,38 @@ const _lastCaptureAt = new Map();
 const _MAX_COOLDOWN_ENTRIES = 200;
 const _syncedMessageCounts = new Map();
 const _MAX_SYNC_CURSOR_ENTRIES = 500;
+const CAPTURE_MESSAGE_MODE_AUTO = "auto";
+const CAPTURE_MESSAGE_MODE_SNAPSHOT = "snapshot";
+const CAPTURE_MESSAGE_MODE_DELTA = "delta";
+
+function parseAgentSessionKey(sessionKey) {
+	const raw = String(sessionKey || "")
+		.trim()
+		.toLowerCase();
+	if (!raw) return null;
+	const parts = raw.split(":").filter(Boolean);
+	if (parts.length < 3 || parts[0] !== "agent") return null;
+	const agentId = parts[1];
+	const rest = parts.slice(2).join(":");
+	if (!agentId || !rest) return null;
+	return { agentId, rest };
+}
+
+function isAgentCronSessionKey(sessionKey) {
+	const parsed = parseAgentSessionKey(sessionKey);
+	return parsed?.rest?.startsWith("cron:") === true;
+}
+
+function isSubagentSessionKey(sessionKey) {
+	const raw = String(sessionKey || "")
+		.trim()
+		.toLowerCase();
+	if (!raw) return false;
+	if (raw.startsWith("subagent:")) return true;
+	const parsed = parseAgentSessionKey(raw);
+	return parsed?.rest?.startsWith("subagent:") === true;
+}
+
 function _setLastCapture(threadId, now) {
 	_lastCaptureAt.set(threadId, now);
 	// Opportunistic eviction: sweep stale entries when map grows large
@@ -68,11 +97,7 @@ function _compileGlob(pattern) {
 	let re = _compiledPatterns.get(key);
 	if (!re) {
 		re = new RegExp(
-			"^" +
-				key
-					.replace(/[.+?^${}()|[\]\\]/g, "\\$&")
-					.replace(/\*/g, "[^:]*") +
-				"$",
+			`^${key.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^:]*")}$`,
 		);
 		_compiledPatterns.set(key, re);
 	}
@@ -95,12 +120,11 @@ export function matchesExcludePattern(sessionKey, patterns) {
 /**
  * Whether automatic thread capture should skip this OpenClaw session.
  *
- * - Agent-scoped cron / isolated-agent keys are classified by
- *   `isCronSessionKey` from `openclaw/plugin-sdk/routing` (same implementation
- *   the gateway uses). Requires OpenClaw >=2026.3.22.
+ * - Agent-scoped cron / isolated-agent keys follow OpenClaw's canonical
+ *   `agent:<id>:cron:*` session-key shape.
  * - Bare `cron:*` keys are still excluded: some internal paths (e.g. delivery /
  *   failure bookkeeping) use that shape without the `agent:` prefix, and
- *   `isCronSessionKey` only parses agent-scoped keys.
+ *   agent-scoped parsing intentionally does not classify bare keys.
  */
 export function isCronCaptureSessionKey(sessionKey) {
 	const raw = String(sessionKey || "")
@@ -108,7 +132,7 @@ export function isCronCaptureSessionKey(sessionKey) {
 		.toLowerCase();
 	if (!raw) return false;
 	if (raw.startsWith("cron:")) return true;
-	return isCronSessionKey(raw);
+	return isAgentCronSessionKey(raw);
 }
 
 /**
@@ -118,7 +142,8 @@ export function isCronCaptureSessionKey(sessionKey) {
  * Exported for reuse by Context Engine and other capture paths.
  */
 export function hasSkipMarker(messages, marker) {
-	if (!marker || typeof marker !== "string" || !Array.isArray(messages)) return false;
+	if (!marker || typeof marker !== "string" || !Array.isArray(messages))
+		return false;
 	const markerLc = marker.toLowerCase();
 	return messages.some((msg) => {
 		const text = extractText(msg?.content ?? msg?.message?.content);
@@ -225,17 +250,45 @@ export function normalizeRoleMessage(
 		timestamp = msg.timestamp;
 	}
 
+	const openclawMeta =
+		msg.__openclaw && typeof msg.__openclaw === "object"
+			? msg.__openclaw
+			: raw.__openclaw && typeof raw.__openclaw === "object"
+				? raw.__openclaw
+				: null;
+	const msgMetadata =
+		msg.metadata && typeof msg.metadata === "object" ? msg.metadata : null;
+	const rawMetadata =
+		raw.metadata && typeof raw.metadata === "object" ? raw.metadata : null;
 	const externalHint = [
+		openclawMeta?.mirrorIdentity,
+		openclawMeta?.idempotencyKey,
+		msg.idempotencyKey,
+		msg.idempotency_key,
 		msg.external_id,
 		msg.externalId,
 		msg.message_id,
 		msg.messageId,
+		msg.openclaw_entry_id,
+		msg.openclawEntryId,
 		msg.id,
+		raw.idempotencyKey,
+		raw.idempotency_key,
 		raw.external_id,
 		raw.externalId,
 		raw.message_id,
 		raw.messageId,
+		raw.openclaw_entry_id,
+		raw.openclawEntryId,
 		raw.id,
+		msgMetadata?.external_id,
+		msgMetadata?.externalId,
+		msgMetadata?.message_id,
+		msgMetadata?.messageId,
+		rawMetadata?.external_id,
+		rawMetadata?.externalId,
+		rawMetadata?.message_id,
+		rawMetadata?.messageId,
 	]
 		.find((v) => typeof v === "string" && v.trim().length > 0)
 		?.trim();
@@ -263,11 +316,26 @@ function sanitizeIdPart(input, max = 48) {
 	return normalized.slice(0, max);
 }
 
-function buildExternalId({ normalized, index, threadId, sessionKey }) {
+function buildExternalId({
+	normalized,
+	index,
+	threadId,
+	sessionKey,
+	event,
+	ctx,
+	messageMode,
+}) {
 	if (normalized.externalHint) {
 		return `oc:${sanitizeIdPart(normalized.externalHint, 96)}`;
 	}
-	const seed = `${threadId}|${sessionKey}|${index}|${normalized.role}|${normalized.content}`;
+	const runId =
+		messageMode === CAPTURE_MESSAGE_MODE_DELTA
+			? String(ctx?.runId || event?.runId || "").trim()
+			: "";
+	const seedParts = [threadId, sessionKey];
+	if (runId) seedParts.push(`run:${runId}`);
+	seedParts.push(index, normalized.role, normalized.content);
+	const seed = seedParts.join("|");
 	const digest = createHash("sha1").update(seed).digest("hex");
 	return `oc-msg:${digest}`;
 }
@@ -286,6 +354,18 @@ function buildAppendIdempotencyKey(threadId, reason, messages) {
 	return `oc-batch:${createHash("sha1").update(JSON.stringify(seed)).digest("hex")}`;
 }
 
+function hasStableExternalHints(normalized) {
+	return (
+		Array.isArray(normalized) &&
+		normalized.length > 0 &&
+		normalized.every(
+			(message) =>
+				typeof message?.externalHint === "string" &&
+				message.externalHint.trim().length > 0,
+		)
+	);
+}
+
 async function loadMessagesFromSessionFile(sessionFile) {
 	try {
 		const content = await readFile(sessionFile, "utf-8");
@@ -328,6 +408,7 @@ export async function appendOrCreateThread({
 	reason,
 	maxMessageChars = DEFAULT_MAX_MESSAGE_CHARS,
 	resolvedMessages,
+	messageMode = CAPTURE_MESSAGE_MODE_SNAPSHOT,
 }) {
 	const rawMessages = resolvedMessages ?? (await resolveHookMessages(event));
 	if (!Array.isArray(rawMessages) || rawMessages.length === 0) return;
@@ -341,22 +422,32 @@ export async function appendOrCreateThread({
 		.filter(Boolean);
 	if (normalized.length === 0) return;
 
-	const allMessages = normalized.map((message, index) => ({
-		role: message.role,
-		content: message.content,
-		timestamp: message.timestamp,
-		metadata: {
-			external_id: buildExternalId({
-				normalized: message,
-				index,
-				threadId,
-				sessionKey,
-			}),
-			source: "openclaw",
-			session_key: sessionKey,
-			session_id: sessionId || undefined,
-		},
-	}));
+	const buildMessages = (resolvedMessageMode) =>
+		normalized.map((message, index) => ({
+			role: message.role,
+			content: message.content,
+			timestamp: message.timestamp,
+			metadata: {
+				external_id: buildExternalId({
+					normalized: message,
+					index,
+					threadId,
+					sessionKey,
+					event,
+					ctx,
+					messageMode: resolvedMessageMode,
+				}),
+				source: "openclaw",
+				session_key: sessionKey,
+				session_id: sessionId || undefined,
+			},
+		}));
+
+	let allMessages = buildMessages(
+		messageMode === CAPTURE_MESSAGE_MODE_DELTA
+			? CAPTURE_MESSAGE_MODE_DELTA
+			: CAPTURE_MESSAGE_MODE_SNAPSHOT,
+	);
 
 	let syncedCount = _syncedMessageCounts.get(threadId);
 	if (syncedCount === undefined) {
@@ -366,6 +457,67 @@ export async function appendOrCreateThread({
 		}
 	}
 
+	const resolvedMessageMode =
+		messageMode === CAPTURE_MESSAGE_MODE_DELTA ||
+		(messageMode === CAPTURE_MESSAGE_MODE_AUTO &&
+			hasStableExternalHints(normalized))
+			? CAPTURE_MESSAGE_MODE_DELTA
+			: CAPTURE_MESSAGE_MODE_SNAPSHOT;
+	if (resolvedMessageMode === CAPTURE_MESSAGE_MODE_DELTA) {
+		allMessages = buildMessages(CAPTURE_MESSAGE_MODE_DELTA);
+		const idempotencyKey = buildAppendIdempotencyKey(
+			threadId,
+			reason,
+			allMessages,
+		);
+		try {
+			const appended = await client.appendThread({
+				threadId,
+				messages: allMessages,
+				deduplicate: true,
+				idempotencyKey,
+			});
+			const added = appended.messagesAdded ?? 0;
+			const total =
+				Number.isFinite(appended.totalMessages) && appended.totalMessages >= 0
+					? appended.totalMessages
+					: typeof syncedCount === "number"
+						? syncedCount + added
+						: allMessages.length;
+			_setSyncedMessageCount(threadId, total);
+			logger.info(
+				`capture: appended ${added} delta messages to ${threadId} (${reason || "event"})`,
+			);
+			return { threadId, normalized, messagesAdded: added };
+		} catch (err) {
+			if (!client.isThreadNotFoundError(err)) {
+				const message = err instanceof Error ? err.message : String(err);
+				logger.warn(
+					`capture: thread append failed for ${threadId}: ${message}`,
+				);
+				return null;
+			}
+		}
+
+		try {
+			const createdId = await client.createThread({
+				threadId,
+				title,
+				messages: allMessages,
+				source: "openclaw",
+			});
+			_setSyncedMessageCount(threadId, allMessages.length);
+			logger.info(
+				`capture: created thread ${createdId} with ${allMessages.length} delta messages (${reason || "event"})`,
+			);
+			return { threadId, normalized, messagesAdded: allMessages.length };
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			logger.warn(`capture: thread create failed for ${threadId}: ${message}`);
+			return null;
+		}
+	}
+
 	if (typeof syncedCount === "number" && syncedCount > allMessages.length) {
 		// OpenClaw compaction can shrink the active transcript after we already
 		// stored the pre-compaction history. Reset the local cursor to the new
@@ -563,9 +715,7 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
 		// Layer 2: marker-based exclusion (user typed #nmem-skip in conversation)
 		const resolvedMessages = await resolveHookMessages(event);
 		if (hasSkipMarker(resolvedMessages, cfg.captureSkipMarker)) {
-			logger.debug?.(
-				`capture: skipped session with skip marker ${sessionKey}`,
-			);
+			logger.debug?.(`capture: skipped session with skip marker ${sessionKey}`);
 			return;
 		}
 
@@ -577,6 +727,7 @@ export function buildAgentEndCaptureHandler(client, cfg, logger) {
 			reason: "agent_end",
 			maxMessageChars: cfg.maxThreadMessageChars,
 			resolvedMessages,
+			messageMode: CAPTURE_MESSAGE_MODE_AUTO,
 		});
 
 		await triageAndDistill({ client, cfg, logger, captureResult, ctx });
@@ -614,9 +765,7 @@ export function buildBeforeResetCaptureHandler(client, cfg, logger) {
 		// Layer 2: marker-based exclusion
 		const resolvedMessages = await resolveHookMessages(event);
 		if (hasSkipMarker(resolvedMessages, cfg.captureSkipMarker)) {
-			logger.debug?.(
-				`capture: skipped session with skip marker ${sessionKey}`,
-			);
+			logger.debug?.(`capture: skipped session with skip marker ${sessionKey}`);
 			return;
 		}
 

package/src/hooks/recall.js

@@ -193,17 +193,21 @@ export function buildRecallHandler(client, cfg, logger, runtime = {}) {
 
 		const sections = [];
 
-		// 1. Working Memory — daily context, not a static profile.
-		// Always injected regardless of search query (WM is independent of user message).
+		// 1. Startup context — identity/guidance plus daily context when available.
+		// Always injected regardless of search query (it is independent of user message).
 		try {
-			const wm = await client.readWorkingMemory();
-			if (wm.available) {
+			const startupContext = await client.readStartupContext();
+			if (startupContext.available) {
+				const tag =
+					startupContext.source === "context-bundle"
+						? "nowledge-context-bundle"
+						: "working-memory";
 				sections.push(
-					`<working-memory>\n${escapeForPrompt(wm.content)}\n</working-memory>`,
+					`<${tag}>\n${escapeForPrompt(startupContext.content)}\n</${tag}>`,
 				);
 			}
 		} catch (err) {
-			logger.error(`recall: working memory read failed: ${err}`);
+			logger.error(`recall: startup context read failed: ${err}`);
 		}
 
 		// 2. Relevant memories — enriched with scoring signals and labels.

package/src/tools/context.js

@@ -1,25 +1,22 @@
 /**
- * nowledge_mem_context — read today's Working Memory.
+ * nowledge_mem_context — read startup context.
  *
- * Working Memory is Nowledge Mem's cognitive-science-grounded daily
- * artifact: focus areas, unresolved flags, recent changes, and
- * priorities — generated by the Knowledge Agent each morning and
- * updated throughout the day as events occur.
+ * Read mode prefers Context Bundle: owner identity, AI Identity, active
+ * space, active rules, Working Memory, and KFS paths. Older nmem clients
+ * fall back to Working Memory.
  *
- * This is fundamentally different from a static "user profile."
- * It's a living document that reflects what matters TODAY.
+ * Patch mode still edits Working Memory sections only.
  */
 export function createContextTool(client, logger) {
 	return {
 		name: "nowledge_mem_context",
 		description:
-			"Read or patch the user's Working Memory — today's focus areas, priorities, unresolved flags, and recent activity. " +
-			"Generated by the Knowledge Agent each morning and updated throughout the day as new knowledge arrives. " +
-			"READ MODE (default): Call with no parameters to understand what the user is currently focused on. " +
+			"Read the user's startup context, or patch Working Memory sections. " +
+			"READ MODE (default): Call with no parameters to load Context Bundle when available: owner identity, AI Identity, active space, active rules, Working Memory, and KFS paths. Older nmem clients fall back to Working Memory. " +
 			"PATCH MODE: Supply patch_section to update just one section without overwriting the rest. " +
 			"Use patch_content to replace the section body, or patch_append to add text to it. " +
 			"Example: patch_section='## Notes', patch_append='New note: ...' to add a note without losing existing content. " +
-			"Note: Working Memory is regenerated by the Knowledge Agent each morning. " +
+			"Note: patch mode edits Working Memory, which is regenerated by the Knowledge Agent each morning. " +
 			"To see what happened recently by date, use nowledge_mem_timeline instead.",
 		parameters: {
 			type: "object",
@@ -100,22 +97,22 @@ export function createContextTool(client, logger) {
 
 			// — READ MODE —
 			try {
-				const wm = await client.readWorkingMemory();
+				const context = await client.readStartupContext();
 
-				if (!wm.available) {
+				if (!context.available) {
 					return {
 						content: [
 							{
 								type: "text",
-								text: "Working Memory not available yet. It is generated by the Knowledge Agent during the daily morning briefing. Ensure Nowledge Mem is running with Background Intelligence enabled.",
+								text: "Startup context is not available yet. Ensure Nowledge Mem is running. Context Bundle requires a recent nmem CLI; older clients fall back to Working Memory generated by Background Intelligence.",
 							},
 						],
 					};
 				}
 
 				return {
-					content: [{ type: "text", text: wm.content }],
-					details: { available: true },
+					content: [{ type: "text", text: context.content }],
+					details: { available: true, source: context.source },
 				};
 			} catch (err) {
 				const msg = err instanceof Error ? err.message : String(err);
@@ -124,7 +121,7 @@ export function createContextTool(client, logger) {
 					content: [
 						{
 							type: "text",
-							text: `Failed to read Working Memory: ${msg}`,
+							text: `Failed to read startup context: ${msg}`,
 						},
 					],
 				};

package/src/tools/status.js

@@ -108,11 +108,11 @@ export function createStatusTool(client, _logger, cfg, runtimeInfo = {}) {
 					);
 					if (cfg.sessionContext) {
 						lines.push(
-							"  Fallback active: Nowledge Mem still injects Working Memory and uses its own recall path.",
+							"  Fallback active: Nowledge Mem still injects startup context and uses its own recall path.",
 						);
 					} else {
 						lines.push(
-							"  Fallback: Nowledge Mem tools remain available. Enable sessionContext for prompt-time Working Memory and recall.",
+							"  Fallback: Nowledge Mem tools remain available. Enable sessionContext for prompt-time startup context and recall.",
 						);
 					}
 					if (corpusSupplementRegistrationError) {