@nowledge/openclaw-nowledge-mem 0.8.36 → 0.8.39

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to the Nowledge Mem OpenClaw plugin will be documented in th
 
 ## Unreleased
 
+## [0.8.39] - 2026-10-18
+
+### Fixed
+
+- Schedule automatic distillation by stored thread ID, without the inline content removed in Mem 0.10.7.
+- Report background task acceptance instead of a synchronous memory count, and reject missing scheduling acknowledgements or an unavailable background scheduler.
+
+## [0.8.38] - 2026-10-17
+
+- Refresh the embedded core 0.2.0 content manifest for Alma adoption; runtime behavior is unchanged.
+
+## [0.8.37] - 2026-10-16
+
+- Embed shared TypeScript core 0.2.0, including the shared prefix-hashing API.
+- Reuse shared persistence acknowledgements and sync timeouts while retaining
+  OpenClaw message projection, compaction-shrink handling, legacy cursors, and
+  response-shape normalization. Reject unsafe acknowledgement counts.
+- Retain embedded-core receipts for both npm and ClawHub artifacts.
+
+
 ## [0.8.36] - 2026-10-11
 
 ### Fixed

package/README.md

@@ -203,7 +203,7 @@ The behavioral skill and always-on hook nudge the agent to **search before answe
 
 ### Session Lifecycle (Automatic Capture)
 
-When sessions end, conversations are captured and optionally distilled. No user action needed.
+Conversations are captured during the session lifecycle. After positive triage, the plugin schedules background distillation of the saved thread. Task acceptance is logged immediately; extracted memories appear after the backend finishes the task. No user action needed.
 
 ```mermaid
 flowchart TD
@@ -216,7 +216,8 @@ flowchart TD
     C --> F{"sessionDigest enabled+ enough messages+ cooldown passed?"}
     F -->|"Yes"| G["LLM triage (~100 tokens):worth distilling?"]
     F -->|"No"| H["Done - thread saved"]
-    G -->|"Decisions, insights,preferences found"| I["Full distillation ->structured memories(with sourceThreadId)"]
+    G -->|"Decisions, insights,preferences found"| I["Schedule background distillation by thread ID"]
+    I --> J["Backend extracts structured memories(with sourceThreadId)"]
     G -->|"Routine chat"| H
 
     D --> H
@@ -226,7 +227,7 @@ flowchart TD
 **Key points:**
 - Thread capture is unconditional: every conversation is saved and searchable via `nowledge_mem_thread_search`
 - Thread sync is incremental: the plugin preserves the real transcript, appends only the unsynced tail, and requires Mem's checkpointed acknowledgement before the local cursor advances
-- LLM distillation only runs at `agent_end`, not during compaction/reset checkpoints
+- Distillation is scheduled from `agent_end` or Context Engine `afterTurn`, not during compaction/reset checkpoints
 - Distilled memories carry `sourceThreadId`, linking them back to the source conversation
 - Cooldown (`digestMinInterval`, default 300s) prevents burst distillation
 

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
 	"id": "openclaw-nowledge-mem",
 	"name": "Nowledge Mem",
 	"description": "Cross-tool knowledge graph memory for OpenClaw with startup context, graph search, and session distillation.",
-	"version": "0.8.36",
+	"version": "0.8.39",
 	"kind": ["memory", "context-engine"],
 	"contracts": {
 		"tools": [

package/package.json

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

package/src/client.js

@@ -849,25 +849,36 @@ export class NowledgeMemClient {
 	}
 
 	/**
-	 * Distill memories from a conversation thread.
-	 * Calls the full distillation endpoint which uses LLM to extract
-	 * structured memories (with unit_type, temporal data, labels).
+	 * Schedule background distillation of an already stored conversation thread.
+	 * Mem 0.10.7+ no longer accepts inline content for distillation.
+	 * The acknowledgement reports task acceptance, not completed memories.
 	 *
-	 * @param {{ threadId: string, title?: string, content: string }} params
+	 * @param {{ threadId: string, title?: string }} params
 	 */
-	async distillThread({ threadId, title, content }) {
-		return this.apiJson(
+	async distillThread({ threadId, title }) {
+		const normalizedThreadId = String(threadId || "").trim();
+		if (!normalizedThreadId) throw new Error("distillThread requires threadId");
+		const result = await this.apiJson(
 			"POST",
-			"/memories/distill",
+			"/memories/distill/schedule",
 			{
-				thread_id: String(threadId || ""),
+				thread_id: normalizedThreadId,
 				thread_title: title || "",
-				thread_content: String(content || ""),
 				distillation_type: "simple_llm",
 				extraction_level: "swift",
 			},
-			60_000, // 60s timeout for LLM distillation
 		);
+		if (
+			result?.success !== true ||
+			typeof result.task_id !== "string" ||
+			!result.task_id.trim()
+		) {
+			throw new Error("Distillation scheduling was not acknowledged with a task ID");
+		}
+		if (result.enqueued === false) {
+			throw new Error("Distillation background scheduler is unavailable");
+		}
+		return result;
 	}
 
 	// ── Thread search ────────────────────────────────────────────────────────

package/src/generated/plugin-core/acknowledgement.d.ts

@@ -0,0 +1,6 @@
+export declare function isThreadAppendAck(data: unknown): boolean;
+export declare function isCheckpointedAppendAck(data: unknown): boolean;
+export declare function appendAcknowledgedRemoteCount(data: unknown): number | undefined;
+export declare function isThreadCreateAck(data: unknown, expectedThreadId: string): boolean;
+export declare function createAcknowledgedRemoteCount(data: unknown, expectedThreadId: string): number | undefined;
+export declare function isCheckpointConflictResponse(data: unknown): boolean;

package/src/generated/plugin-core/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./thread-delta.js";
+export * from "./acknowledgement.js";
+export * from "./timeout.js";

package/src/generated/plugin-core/index.js

@@ -0,0 +1,92 @@
+// Generated from shared/plugin-core. Run npm --prefix shared/plugin-core run build.
+
+// src/thread-delta.ts
+import { createHash } from "node:crypto";
+function stableMessageFingerprint(message) {
+  return JSON.stringify(message);
+}
+function prefixFingerprint(messages, end, messageFingerprint) {
+  const hash = createHash("sha256");
+  for (const message of messages.slice(0, end)) {
+    const value = messageFingerprint(message);
+    hash.update(String(Buffer.byteLength(value)));
+    hash.update(":");
+    hash.update(value);
+  }
+  return hash.digest("hex");
+}
+function selectAcknowledgedDelta(messages, cursor, externalId, messageFingerprint = stableMessageFingerprint) {
+  let start = cursor?.count ?? 0;
+  const validCount = Number.isSafeInteger(start) && start >= 0 && start <= messages.length;
+  const prefixMatches = validCount && (start === 0 || externalId(messages[start - 1]) === cursor?.lastExternalId && prefixFingerprint(messages, start, messageFingerprint) === cursor?.prefixFingerprint);
+  const reset = !prefixMatches;
+  if (reset) start = 0;
+  const end = messages.length;
+  return {
+    start,
+    end,
+    messages: messages.slice(start),
+    next: {
+      count: end,
+      remoteCount: cursor?.remoteCount ?? end,
+      ...end > 0 ? { lastExternalId: externalId(messages[end - 1]) } : {},
+      prefixFingerprint: prefixFingerprint(messages, end, messageFingerprint)
+    },
+    reset
+  };
+}
+
+// src/acknowledgement.ts
+function record(value) {
+  return typeof value === "object" && value !== null;
+}
+function messageCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isThreadAppendAck(data) {
+  return record(data) && data.success === true && messageCount(data.messages_added) && messageCount(data.total_messages);
+}
+function isCheckpointedAppendAck(data) {
+  return isThreadAppendAck(data) && data.append_mode === "checkpointed";
+}
+function appendAcknowledgedRemoteCount(data) {
+  return isThreadAppendAck(data) ? data.total_messages : void 0;
+}
+function isThreadCreateAck(data, expectedThreadId) {
+  return record(data) && record(data.thread) && data.thread.thread_id === expectedThreadId;
+}
+function createAcknowledgedRemoteCount(data, expectedThreadId) {
+  if (!isThreadCreateAck(data, expectedThreadId)) return void 0;
+  const result = data;
+  if (result.thread.message_count !== void 0) {
+    return messageCount(result.thread.message_count) ? result.thread.message_count : void 0;
+  }
+  return Array.isArray(result.messages) ? result.messages.length : void 0;
+}
+function isCheckpointConflictResponse(data) {
+  return record(data) && data.error_code === "checkpoint_conflict";
+}
+
+// src/timeout.ts
+var DEFAULT_THREAD_SYNC_TIMEOUT_MS = 12e4;
+var MIN_THREAD_SYNC_TIMEOUT_MS = 1e3;
+var MAX_THREAD_SYNC_TIMEOUT_MS = 30 * 6e4;
+function resolveThreadSyncTimeoutMs(raw) {
+  const parsed = Number(raw);
+  if (!raw?.trim() || !Number.isSafeInteger(parsed) || parsed <= 0) {
+    return DEFAULT_THREAD_SYNC_TIMEOUT_MS;
+  }
+  return Math.min(MAX_THREAD_SYNC_TIMEOUT_MS, Math.max(MIN_THREAD_SYNC_TIMEOUT_MS, parsed));
+}
+export {
+  appendAcknowledgedRemoteCount,
+  createAcknowledgedRemoteCount,
+  isCheckpointConflictResponse,
+  isCheckpointedAppendAck,
+  isThreadAppendAck,
+  isThreadCreateAck,
+  prefixFingerprint,
+  resolveThreadSyncTimeoutMs,
+  selectAcknowledgedDelta,
+  stableMessageFingerprint
+};

package/src/generated/plugin-core/manifest.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "core": {
+    "name": "@nowledge/plugin-core",
+    "version": "0.2.0",
+    "sourceDigest": "f06362cae4cdb5cd24a1eab4420860d41ab707f1558a25b779fcb3d74c651c56"
+  },
+  "build": {
+    "target": "es2022",
+    "format": "esm",
+    "esbuild": "0.25.9",
+    "typescript": "5.6.3"
+  },
+  "files": {
+    "acknowledgement.d.ts": "ffd0fd090f289c4deafba41d9faa83fb7f4a6070bd53588de5d1a947b076f65a",
+    "index.d.ts": "6e7965f903a043a34c3dd454f909e878134c1bf451ec7ff3c3026f035f1aaee0",
+    "index.js": "0e25a05abe9f9282dc6a7d3cc64a3da872c1e5192908308ee5086c0465f6c032",
+    "package.json": "609158e6c5fbc237939fa3ddf7faab80ab690bdc0c8d584414a885130103c4e8",
+    "thread-delta.d.ts": "83f31e3334086f6fdfe5e6e1b1c4b1a994bb6d49fda2fdedf450d14f4ec18cba",
+    "timeout.d.ts": "85bfd4185e9d0b22073250b5cbe19da38613d9af9fbc2022403ebb527dad9f8f"
+  }
+}

package/src/generated/plugin-core/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}

package/src/generated/plugin-core/thread-delta.d.ts

@@ -0,0 +1,17 @@
+export type AcknowledgedCursor = {
+    count: number;
+    remoteCount: number;
+    lastExternalId?: string;
+    prefixFingerprint: string;
+};
+export type AcknowledgedDelta<T> = {
+    start: number;
+    end: number;
+    messages: T[];
+    next: AcknowledgedCursor;
+    reset: boolean;
+};
+export declare function stableMessageFingerprint(message: unknown): string;
+export declare function prefixFingerprint<T>(messages: readonly T[], end: number, messageFingerprint: (message: T) => string): string;
+/** The returned cursor is a candidate; only persistence acknowledgement commits it. */
+export declare function selectAcknowledgedDelta<T>(messages: readonly T[], cursor: AcknowledgedCursor | undefined, externalId: (message: T) => string, messageFingerprint?: (message: T) => string): AcknowledgedDelta<T>;

package/src/generated/plugin-core/timeout.d.ts

@@ -0,0 +1 @@
+export declare function resolveThreadSyncTimeoutMs(raw: string | undefined): number;

package/src/hooks/capture.js

@@ -742,7 +742,7 @@ async function persistMessages({
 
 /**
  * Build a plain-text conversation string from normalized messages.
- * Used as input for triage and distillation.
+ * Used as input for triage; distillation reads the stored thread.
  *
  * Per-message content is capped at MAX_DISTILL_MESSAGE_CHARS and the
  * total output at MAX_CONVERSATION_CHARS to keep LLM API payloads
@@ -823,15 +823,10 @@ export async function triageAndDistill({
 		const distillResult = await client.distillThread({
 			threadId: captureResult.threadId,
 			title: buildThreadTitle(ctx, captureResult.normalized),
-			content: conversationText,
 		});
 
-		const count =
-			distillResult?.memories_created ??
-			distillResult?.created_memories?.length ??
-			0;
 		logger.info(
-			`capture: distilled ${count} memories from ${captureResult.threadId}`,
+			`capture: scheduled background distillation for ${captureResult.threadId} (task ${distillResult.task_id})`,
 		);
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);

package/src/session-delta.js

@@ -1,4 +1,14 @@
 import { createHash } from "node:crypto";
+import {
+	createAcknowledgedRemoteCount,
+	prefixFingerprint as corePrefixFingerprint,
+} from "./generated/plugin-core/index.js";
+
+export {
+	isCheckpointConflictResponse,
+	isCheckpointedAppendAck,
+	isThreadAppendAck,
+} from "./generated/plugin-core/index.js";
 
 export function sessionSyncLaneKey(threadId, apiUrl, apiKey, spaceId) {
 	const destination = createHash("sha256")
@@ -24,54 +34,27 @@ export function prefixFingerprint(
 	end,
 	messageFingerprint = stableMessageFingerprint,
 ) {
-	const hash = createHash("sha256");
-	for (const message of messages.slice(0, end)) {
-		const value = messageFingerprint(message);
-		hash.update(String(Buffer.byteLength(value)));
-		hash.update(":");
-		hash.update(value);
-	}
-	return hash.digest("hex");
-}
-
-export function isThreadAppendAck(data) {
-	return (
-		data !== null &&
-		typeof data === "object" &&
-		data.success === true &&
-		Number.isInteger(data.messages_added) &&
-		data.messages_added >= 0 &&
-		Number.isInteger(data.total_messages) &&
-		data.total_messages >= 0
-	);
+	return corePrefixFingerprint(messages, end, messageFingerprint);
 }
 
 export function threadCreateAck(data, expectedThreadId) {
 	if (data === null || typeof data !== "object") return null;
 	const thread =
-		data.thread !== null && typeof data.thread === "object" ? data.thread : data;
+		data.thread !== null && typeof data.thread === "object"
+			? data.thread
+			: data;
 	const threadId = String(thread.thread_id ?? "").trim();
-	const totalMessages = thread.message_count ?? thread.total_messages;
-	if (
-		threadId !== String(expectedThreadId || "").trim() ||
-		!Number.isInteger(totalMessages) ||
-		totalMessages < 0
-	) {
-		return null;
-	}
-	return { threadId, totalMessages };
-}
-
-export function isCheckpointedAppendAck(data) {
-	return isThreadAppendAck(data) && data.append_mode === "checkpointed";
-}
-
-export function isCheckpointConflictResponse(data) {
-	return (
-		data !== null &&
-		typeof data === "object" &&
-		data.error_code === "checkpoint_conflict"
+	const totalMessages = createAcknowledgedRemoteCount(
+		{
+			thread: {
+				thread_id: threadId,
+				message_count: thread.message_count ?? thread.total_messages,
+			},
+		},
+		String(expectedThreadId || "").trim(),
 	);
+	if (totalMessages === undefined) return null;
+	return { threadId, totalMessages };
 }
 
 export function selectSnapshotDelta(
@@ -102,9 +85,7 @@ export function selectSnapshotDelta(
 		};
 	}
 	const acknowledgedPrefix =
-		start >= 0
-			? prefixFingerprint(messages, start, messageFingerprint)
-			: "";
+		start >= 0 ? prefixFingerprint(messages, start, messageFingerprint) : "";
 	const fingerprintTrusted = Boolean(cursor?.prefixFingerprint);
 	const externalIdTrusted = Boolean(cursor?.lastExternalId);
 	if (
@@ -134,7 +115,13 @@ export function selectSnapshotDelta(
 	};
 }
 
-export function contentBoundIdempotencyKey(prefix, threadId, start, end, fingerprint) {
+export function contentBoundIdempotencyKey(
+	prefix,
+	threadId,
+	start,
+	end,
+	fingerprint,
+) {
 	return `${prefix}:${threadId}:${start}-${end}:${fingerprint}`;
 }
 

package/src/thread-sync-timeout.js

@@ -1,14 +1 @@
-const DEFAULT_THREAD_SYNC_TIMEOUT_MS = 120_000;
-const MIN_THREAD_SYNC_TIMEOUT_MS = 1_000;
-const MAX_THREAD_SYNC_TIMEOUT_MS = 30 * 60_000;
-
-export function resolveThreadSyncTimeoutMs(raw) {
-	const parsed = Number(raw);
-	if (!String(raw ?? "").trim() || !Number.isSafeInteger(parsed) || parsed <= 0) {
-		return DEFAULT_THREAD_SYNC_TIMEOUT_MS;
-	}
-	return Math.min(
-		MAX_THREAD_SYNC_TIMEOUT_MS,
-		Math.max(MIN_THREAD_SYNC_TIMEOUT_MS, parsed),
-	);
-}
+export { resolveThreadSyncTimeoutMs } from "./generated/plugin-core/index.js";