@openclaw/memory-lancedb 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/lancedb-store.js

@@ -1,9 +1,11 @@
 import { loadLanceDbModule } from "./lancedb-runtime.js";
 import { MEMORY_TABLE_NAME, hasAgentScopeColumn, legacyMemorySchemaError, memoryAgentPredicate, quoteLanceSqlString } from "./lancedb-schema.js";
 import { randomUUID } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+import { Field, FixedSizeList, Float32, Float64, Schema, Utf8 } from "apache-arrow";
 //#region extensions/memory-lancedb/lancedb-store.ts
-const SCHEMA_SENTINEL_ID = "__schema__";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TABLE_INITIALIZATION_ATTEMPTS = 3;
 const MEMORY_QUERY_COLUMNS = [
 	"id",
 	"text",
@@ -11,6 +13,33 @@ const MEMORY_QUERY_COLUMNS = [
 	"category",
 	"createdAt"
 ];
+function createMemoryTableSchema(vectorDim) {
+	return new Schema([
+		new Field("id", new Utf8(), true),
+		new Field("text", new Utf8(), true),
+		new Field("vector", new FixedSizeList(vectorDim, new Field("item", new Float32(), true)), true),
+		new Field("importance", new Float64(), true),
+		new Field("category", new Utf8(), true),
+		new Field("createdAt", new Float64(), true),
+		new Field("agentId", new Utf8(), true)
+	]);
+}
+async function openOrCreateMemoryTable(db, vectorDim) {
+	let lastError;
+	for (let attempt = 1; attempt <= TABLE_INITIALIZATION_ATTEMPTS; attempt += 1) {
+		let table = null;
+		try {
+			table = (await db.tableNames()).includes("memories") ? await db.openTable(MEMORY_TABLE_NAME) : await db.createEmptyTable(MEMORY_TABLE_NAME, createMemoryTableSchema(vectorDim), { existOk: true });
+			await table.schema();
+			return table;
+		} catch (error) {
+			table?.close();
+			lastError = error;
+			if (attempt < TABLE_INITIALIZATION_ATTEMPTS) await setTimeout(attempt * 10);
+		}
+	}
+	throw lastError;
+}
 function formatQueryFilter(filter) {
 	if (filter.operator === "LIKE" && typeof filter.value !== "string") throw new Error("LIKE requires a string memory filter value");
 	if (typeof filter.value === "number" && !Number.isFinite(filter.value)) throw new Error("Memory filter number must be finite");
@@ -45,21 +74,8 @@ var MemoryDB = class {
 		const db = await lancedb.connect(this.dbPath, connectionOptions);
 		let table = null;
 		try {
-			if ((await db.tableNames()).includes("memories")) {
-				table = await db.openTable(MEMORY_TABLE_NAME);
-				if (!hasAgentScopeColumn(await table.schema())) throw legacyMemorySchemaError();
-			} else {
-				table = await db.createTable(MEMORY_TABLE_NAME, [{
-					id: SCHEMA_SENTINEL_ID,
-					text: "",
-					vector: Array.from({ length: this.vectorDim }).fill(0),
-					importance: 0,
-					category: "other",
-					createdAt: 0,
-					agentId: SCHEMA_SENTINEL_ID
-				}]);
-				await table.delete(`id = ${quoteLanceSqlString(SCHEMA_SENTINEL_ID)}`);
-			}
+			table = await openOrCreateMemoryTable(db, this.vectorDim);
+			if (!hasAgentScopeColumn(await table.schema())) throw legacyMemorySchemaError();
 			this.db = db;
 			this.table = table;
 		} catch (error) {

package/dist/memory-capture-sanitization.js

@@ -0,0 +1,346 @@
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { BUNDLED_CHAT_CHANNEL_ENVELOPE_PREFIXES } from "openclaw/plugin-sdk/chat-channel-ids";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";
+//#region extensions/memory-lancedb/memory-capture-sanitization.ts
+const MEDIA_NOTE_HEADER = /^\[media attached(?: \d+\/\d+)?: /;
+function stripMediaNoteLine(line) {
+	return MEDIA_NOTE_HEADER.test(line) && line.endsWith("]") ? null : line;
+}
+function dropMediaNoteLines(text) {
+	return text.split("\n").map(stripMediaNoteLine).filter((line) => line !== null).join("\n");
+}
+/**
+* Provenance marker appended to every OpenClaw-injected inbound context header
+* by `buildInboundUserContextPrefix`. `sanitizeForMemoryCapture` and
+* `looksLikeEnvelopeSludge` key on this marker rather than on label text, so
+* detection is label-agnostic (arbitrary plugin `ChannelStructuredContext`
+* labels are covered) and never collides with a user's own `<heading>:` + JSON.
+* The marker glyph is duplicated inline in the regexes below because extensions
+* must not import core internals; keep byte-identical with
+* `src/auto-reply/reply/inbound-context-marker.ts`.
+*/
+const MARKER_HEADER_LINE_RE = /^[^\n]*⟦openclaw:ctx⟧[ \t]*$/m;
+const MARKER_JSON_BLOCK_RE = /^[^\n]*⟦openclaw:ctx⟧[ \t]*\n[ \t]*```json[ \t]*\n[\s\S]*?\n[ \t]*```[ \t]*\n?/gm;
+const LEADING_CHRONOLOGICAL_MARKER_HEADER_RE = /^\s*[^\n]*chronological[^\n]*⟦openclaw:ctx⟧[ \t]*(?:\n|$)/;
+const MESSAGE_TOOL_DELIVERY_HINT_RE = new RegExp(`^\\s*(?:${MESSAGE_TOOL_DELIVERY_HINTS.map((hint) => hint.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\s*$`, "m");
+const HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
+const CURRENT_MESSAGE_MARKER = "[Current message - respond to this]";
+const HISTORY_CONTEXT_MARKERS = [
+	HISTORY_CONTEXT_MARKER,
+	"[Chat messages since your last reply — CONTEXT ONLY]",
+	"[Merged earlier messages — CONTEXT ONLY]"
+];
+const CURRENT_MESSAGE_MARKERS = [
+	CURRENT_MESSAGE_MARKER,
+	"[CURRENT MESSAGE — reply to this]",
+	"[CURRENT MESSAGE — reply using the context above]"
+];
+const ACTIVE_TURN_RECOVERY_RE = /active-turn-recovery/i;
+const BRACKETED_PREFIX_RE = /\[[^\]\n]{1,500}\]\s/g;
+const LEADING_CURRENT_MESSAGE_CONTEXT_RE = /^\s*Current message:[ \t]*(?:\n|$)/;
+const LEADING_CURRENT_MESSAGE_REPLY_LINE_RE = /^\s*\[Replying to:[^\n]{0,1000}\]\s*\n/;
+const LEADING_CURRENT_MESSAGE_ID_SENDER_RE = /^#\d+\s+[^\n:]{1,100}:\s*/;
+const CONTEXT_HEADER_RE = /^Context:[ \t]*⟦openclaw:ctx⟧[ \t]*$/m;
+/**
+* Matches JSON blobs that look like OpenClaw transport envelope metadata.
+* Orthogonal to the header marker: it catches a bare envelope payload by its
+* compound keys even when no marker header precedes it (e.g. a fragment that
+* leaked outside its ```json fence). Core's `formatContextJsonBlock` emits
+* compact single-line JSON; the optional-newline branch also catches legacy
+* pretty-printed blocks. Key list mirrors envelope identifiers used by
+* `buildInboundUserContextPrefix` and stays narrow to avoid false-positives on
+* legitimate user JSON with bare keys like "conversation" or "sender".
+*/
+const ENVELOPE_JSON_LINE_RE = /^\s*\{\s*(?:\n\s*)?"(?:chat_id|message_id|reply_to_id|sender_id|conversation_label|conversation_info|sender_name|channel_id|channel_type|group_subject|group_channel|group_space|topic_id|thread_label)"\s*:/m;
+/**
+* Leading bracketed envelope header injected by `formatAgentEnvelope` /
+* `formatInboundEnvelope` (src/auto-reply/envelope.ts). Real shape, with parts
+* joined by spaces inside a single `[...]`:
+*
+*   `[<channel> <from> +<elapsed>? <host>? <ip>? <Wkd YYYY-MM-DD HH:MM TZ>?] <body>`
+*
+* Examples:
+*   `[Telegram Alice +5m] I prefer dark mode`
+*   `[Telegram Group id:123 Alice +5m Mon 2026-05-17 14:30 EDT] Alice: text`
+*   `[Discord #general user +0s Mon 2026-05-17T14:30Z] text`
+*
+* Detection keys on the load-bearing parts that mark this header as an
+* envelope (rather than arbitrary user-typed `[brackets]`): an elapsed marker
+* `+<n><unit>` produced by `formatTimeAgo({suffix:false})` (units: s/m/h/d, or
+* the literal `just now` fallback), or a weekday + ISO date pair produced by
+* `formatEnvelopeTimestamp`. Either marker is unique enough that quoting
+* `[5m]` or `[Mon 2026-05-17]` mid-sentence will not look like an envelope
+* prefix because the regex is anchored to start-of-string and requires the
+* marker to live inside the leading bracket followed by `]<space>`.
+*
+* Capture group 1 is the inside-bracket text, used by the sender-prefix
+* gating logic in `sanitizeForMemoryCapture` to scope which body labels we
+* are willing to strip. Header part length is capped at 300 chars to avoid
+* catastrophic backtracking on pathological inputs; real envelopes are well
+* under that.
+*/
+const INBOUND_ENVELOPE_PREFIX_RE = /^\[([^\]\n]{0,300}?(?:\s\+(?:\d+[smhdwy]|just now)\b|\s[A-Za-z]{3}\s\d{4}-\d{2}-\d{2})[^\]\n]{0,200})\]\s/;
+/**
+* Marker-free leading envelope header. The elapsed/date marker regex above
+* misses envelopes where `formatAgentEnvelope` drops every optional marker.
+* Because channel labels can also be ordinary words, callers only accept this
+* match after `matchKnownChannelMarkerFreeEnvelopePrefix` finds a stronger
+* group/thread or body-sender signal.
+*
+* Anchoring on a known bundled/official channel prefix from
+* `BUNDLED_CHAT_CHANNEL_ENVELOPE_PREFIXES` keeps the detector and formatter in
+* sync across callers that pass either ids or display labels like `Google Chat`.
+* Case insensitive because the formatter does not lowercase `params.channel`
+* itself; production paths feed mixed ids and labels.
+*
+* From-label must be at least one non-whitespace token so user prose like
+* `[note]` or `[telegram] ...` (no following label) is not mistaken for an
+* envelope. Capture group 1 is the inside-bracket text (channel + from-label
+* and any remaining header parts), used by the sender-prefix gating logic in
+* `sanitizeForMemoryCapture`. Header part length is capped at 300 chars to
+* match the marker-aware regex above and avoid catastrophic backtracking.
+*
+* Guarded against an empty `BUNDLED_CHAT_CHANNEL_ENVELOPE_PREFIXES` so the
+* alternation never degenerates into `(?:)` (which would match the empty string
+* and flag every `[...]` prefix as an envelope). When the bundled list is empty the
+* known-channel detector is disabled and only the marker-aware regex above
+* applies.
+*/
+const ENVELOPE_KNOWN_CHANNEL_PATTERN = BUNDLED_CHAT_CHANNEL_ENVELOPE_PREFIXES.map((prefix) => prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+const INBOUND_ENVELOPE_KNOWN_CHANNEL_PREFIX_RE = ENVELOPE_KNOWN_CHANNEL_PATTERN ? new RegExp(`^\\[((?:${ENVELOPE_KNOWN_CHANNEL_PATTERN})\\s+[^\\]\\n\\s][^\\]\\n]{0,299})\\]\\s`, "i") : null;
+/**
+* Group-chat envelope bodies prepend `<Sender>: ` to the raw user text (see
+* `formatInboundEnvelope`). After stripping the leading envelope bracket,
+* this pattern matches that body sender prefix; capture group 1 is the label
+* itself so the gated strip in `sanitizeForMemoryCapture` can compare it
+* against the envelope header before removing it. Sender label is capped at
+* the same length as `sanitizeEnvelopeHeaderPart` would produce in practice
+* (the envelope formatter does not truncate, but a 120-char ceiling keeps the
+* regex bounded and matches realistic display names).
+*/
+const ENVELOPE_BODY_SENDER_PREFIX_RE = /^([^\n:]{1,120}):\s/;
+const ENVELOPE_BODY_DIRECT_PREFIX = "(sender)";
+const ENVELOPE_BODY_SELF_PREFIX = "(self)";
+const SENDER_PREFIXED_ENVELOPE_CHANNEL_RE = /^(?:discord|imessage|line|mattermost|qqbot|signal|slack|telegram|whatsapp)(?:\s|$)/i;
+const NON_DIRECT_ENVELOPE_HEADER_RE = /(?:^|\s)(?:#[^\s]+|group:[^\s]+|group\s+id:[^\s]+|room:[^\s]+|channel\s+id:[^\s]+|id:-[^\s]+|unknown-group|[^\s]+@g\.us)(?:\s|$)/i;
+const USER_AUTHORED_BODY_LABEL_RE = /^(?:action|decision|fixme|note|question|reminder|todo)$/i;
+function matchKnownChannelMarkerFreeEnvelopePrefix(text, options) {
+	const match = INBOUND_ENVELOPE_KNOWN_CHANNEL_PREFIX_RE?.exec(text);
+	if (!match) return null;
+	const headerInside = match[1] ?? "";
+	if (NON_DIRECT_ENVELOPE_HEADER_RE.test(headerInside)) return match;
+	const body = text.slice(match[0].length);
+	if (stripEnvelopeBodySenderPrefix(body, headerInside) !== body) return match;
+	return options?.allowAmbiguousDirect ? match : null;
+}
+/**
+* Returns true if `text` looks like it contains OpenClaw-injected envelope or
+* transport metadata that should never be persisted as a long-term memory.
+*/
+function looksLikeEnvelopeSludge(text) {
+	if (!text) return false;
+	if (MARKER_HEADER_LINE_RE.test(text)) return true;
+	if (MESSAGE_TOOL_DELIVERY_HINT_RE.test(text)) return true;
+	if (HISTORY_CONTEXT_MARKERS.some((marker) => text.includes(marker)) || CURRENT_MESSAGE_MARKERS.some((marker) => text.includes(marker))) return true;
+	if (ACTIVE_TURN_RECOVERY_RE.test(text)) return true;
+	if (ENVELOPE_JSON_LINE_RE.test(text)) return true;
+	return INBOUND_ENVELOPE_PREFIX_RE.test(text) || matchKnownChannelMarkerFreeEnvelopePrefix(text) !== null;
+}
+/**
+* Timestamp prefix pattern injected by `injectTimestamp`.
+* Canonical source: src/auto-reply/reply/strip-inbound-meta.ts
+*/
+const LEADING_TIMESTAMP_PREFIX_RE = /^\[[A-Za-z]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\]]*\] */;
+/**
+* Decide whether a `<X>: ` body prefix that follows a stripped envelope
+* bracket was emitted by the formatter (vs being user-typed prose). The
+* formatter contract in `src/auto-reply/envelope.ts` only ever prepends:
+*   - `(self): ` for direct chats with `fromMe`, OR
+*   - `<resolvedSender>: ` for non-direct chats with a sender label.
+*
+* Some channel paths call `formatInboundEnvelope` and therefore put the room in
+* the header while keeping the sender as the body label, for example
+* `[Slack #general] Alice: text`. Generic `formatAgentEnvelope` callers and
+* direct `formatInboundEnvelope` bodies do not add that body label, so require
+* structural non-direct markers and preserve common user-authored labels like
+* `TODO:`.
+*/
+function stripEnvelopeBodySenderPrefix(body, headerInside) {
+	const match = body.match(ENVELOPE_BODY_SENDER_PREFIX_RE);
+	if (!match) return body;
+	const label = expectDefined(match[1], "envelope body sender capture");
+	if (label === ENVELOPE_BODY_SELF_PREFIX || label === ENVELOPE_BODY_DIRECT_PREFIX) return body.slice(match[0].length);
+	if (SENDER_PREFIXED_ENVELOPE_CHANNEL_RE.test(headerInside) && NON_DIRECT_ENVELOPE_HEADER_RE.test(headerInside) && !USER_AUTHORED_BODY_LABEL_RE.test(label)) return body.slice(match[0].length);
+	if (headerInside.split(/\s+/).includes(label) || headerInside.includes(label)) return body.slice(match[0].length);
+	return body;
+}
+function stripLeadingMessageToolDeliveryHints(text) {
+	const lines = text.split("\n");
+	let index = 0;
+	let stripped = false;
+	while (index < lines.length) {
+		const trimmed = lines[index]?.trim();
+		if (!trimmed) {
+			index += 1;
+			continue;
+		}
+		if (!MESSAGE_TOOL_DELIVERY_HINTS.some((hint) => hint === trimmed)) break;
+		stripped = true;
+		index += 1;
+	}
+	return stripped ? lines.slice(index).join("\n") : text;
+}
+function findFirstInboundEnvelopeIndex(text, options) {
+	for (const match of text.matchAll(BRACKETED_PREFIX_RE)) {
+		const index = match.index;
+		if (options?.skipReplyQuoteLine) {
+			const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+			if (text.slice(lineStart, index).includes("[Replying to:")) continue;
+		}
+		const candidate = text.slice(index);
+		if (INBOUND_ENVELOPE_PREFIX_RE.test(candidate) || matchKnownChannelMarkerFreeEnvelopePrefix(candidate, { allowAmbiguousDirect: options?.allowAmbiguousMarkerFree })) return index;
+	}
+	return -1;
+}
+function stripPendingHistoryContextBeforeCurrentMessage(text) {
+	const candidateText = text.trimStart();
+	if (!HISTORY_CONTEXT_MARKERS.some((marker) => candidateText.startsWith(marker))) return text;
+	const currentMarker = findLastContextMarker(candidateText, CURRENT_MESSAGE_MARKERS);
+	if (!currentMarker) return text;
+	return candidateText.slice(currentMarker.index + currentMarker.marker.length);
+}
+function stripToCurrentMessageMarker(text) {
+	const currentMarker = findLastContextMarker(text, CURRENT_MESSAGE_MARKERS);
+	if (!currentMarker) return null;
+	return text.slice(currentMarker.index + currentMarker.marker.length);
+}
+function findLastContextMarker(text, markers) {
+	let result = null;
+	for (const marker of markers) {
+		const index = text.lastIndexOf(marker);
+		if (index !== -1 && (!result || index > result.index)) result = {
+			index,
+			marker
+		};
+	}
+	return result;
+}
+function stripLeadingCurrentMessageContextBeforeEnvelope(text) {
+	const candidateText = text.trimStart();
+	if (!LEADING_CURRENT_MESSAGE_CONTEXT_RE.test(candidateText)) return text;
+	const envelopeIndex = findFirstInboundEnvelopeIndex(candidateText, {
+		allowAmbiguousMarkerFree: true,
+		skipReplyQuoteLine: true
+	});
+	if (envelopeIndex === -1) {
+		let plainBody = candidateText.replace(LEADING_CURRENT_MESSAGE_CONTEXT_RE, "").trimStart();
+		for (let pass = 0; pass < 4; pass += 1) {
+			const replyLineMatch = plainBody.match(LEADING_CURRENT_MESSAGE_REPLY_LINE_RE);
+			if (!replyLineMatch) break;
+			plainBody = plainBody.slice(replyLineMatch[0].length).trimStart();
+		}
+		const currentMessagePrefixMatch = plainBody.match(LEADING_CURRENT_MESSAGE_ID_SENDER_RE);
+		return currentMessagePrefixMatch ? plainBody.slice(currentMessagePrefixMatch[0].length) : text;
+	}
+	return candidateText.slice(envelopeIndex);
+}
+function stripLeadingPlainTextMetadataBody(text) {
+	const candidateText = text.trimStart();
+	const markerBody = stripToCurrentMessageMarker(candidateText);
+	if (markerBody !== null) return markerBody;
+	const currentMessageBody = stripLeadingCurrentMessageContextBeforeEnvelope(candidateText);
+	return currentMessageBody === candidateText ? "" : currentMessageBody;
+}
+function stripLeadingInboundEnvelope(text, options) {
+	const strippedCandidate = stripLeadingCurrentMessageContextBeforeEnvelope(stripPendingHistoryContextBeforeCurrentMessage(stripLeadingMessageToolDeliveryHints(text)));
+	const candidateText = strippedCandidate.trimStart();
+	const allowAmbiguousMarkerFree = options?.allowAmbiguousMarkerFree || strippedCandidate !== text;
+	const envelopePrefixMatch = candidateText.match(INBOUND_ENVELOPE_PREFIX_RE) ?? matchKnownChannelMarkerFreeEnvelopePrefix(candidateText, { allowAmbiguousDirect: allowAmbiguousMarkerFree });
+	if (!envelopePrefixMatch) return strippedCandidate === text ? text : candidateText;
+	const headerInside = envelopePrefixMatch[1] ?? "";
+	return stripEnvelopeBodySenderPrefix(candidateText.slice(envelopePrefixMatch[0].length), headerInside);
+}
+function stripLeadingChronologicalContextBlocks(text) {
+	let cleaned = text;
+	let remainingPasses = 16;
+	while (remainingPasses > 0) {
+		remainingPasses -= 1;
+		const match = cleaned.match(LEADING_CHRONOLOGICAL_MARKER_HEADER_RE);
+		if (!match) return cleaned;
+		const afterLabel = cleaned.slice(match[0].length);
+		const bodyStart = afterLabel.search(/\S/);
+		if (bodyStart === -1) return "";
+		const bodyLineEnd = afterLabel.indexOf("\n", bodyStart);
+		const firstBodyLine = bodyLineEnd === -1 ? afterLabel.slice(bodyStart) : afterLabel.slice(bodyStart, bodyLineEnd);
+		let lineEnvelopeIndex = firstBodyLine.trimStart().startsWith("[") ? findFirstInboundEnvelopeIndex(firstBodyLine, {
+			allowAmbiguousMarkerFree: true,
+			skipReplyQuoteLine: true
+		}) : -1;
+		if (lineEnvelopeIndex === -1 && match[0].includes("selected for current message")) {
+			const inlineEnvelopeIndex = findFirstInboundEnvelopeIndex(firstBodyLine, {
+				allowAmbiguousMarkerFree: true,
+				skipReplyQuoteLine: true
+			});
+			const prefix = inlineEnvelopeIndex === -1 ? "" : firstBodyLine.slice(0, inlineEnvelopeIndex);
+			lineEnvelopeIndex = /^#\d+\s/.test(prefix.trimStart()) ? inlineEnvelopeIndex : -1;
+		}
+		const envelopeIndex = lineEnvelopeIndex === -1 ? -1 : bodyStart + lineEnvelopeIndex;
+		if (envelopeIndex === -1) {
+			const separatorMatch = /\n[ \t]*\n/.exec(afterLabel);
+			cleaned = separatorMatch ? afterLabel.slice(separatorMatch.index + separatorMatch[0].length) : "";
+		} else cleaned = afterLabel.slice(envelopeIndex);
+		if (!cleaned) return "";
+	}
+	return cleaned;
+}
+/**
+* Strips OpenClaw-injected envelope metadata from a user message so that only
+* the user's actual intent text remains. Returns empty string if nothing
+* meaningful survives.
+*/
+function sanitizeForMemoryCapture(text) {
+	if (!text) return "";
+	const MAX_SANITIZE_CHARS = 1e4;
+	let cleaned = text.length > MAX_SANITIZE_CHARS ? truncateUtf16Safe(text, MAX_SANITIZE_CHARS) : text;
+	let strippedInjectedContext = false;
+	cleaned = cleaned.replace(LEADING_TIMESTAMP_PREFIX_RE, "");
+	cleaned = dropMediaNoteLines(cleaned);
+	const afterDeliveryHints = stripLeadingMessageToolDeliveryHints(cleaned);
+	strippedInjectedContext ||= afterDeliveryHints !== cleaned;
+	cleaned = afterDeliveryHints;
+	const afterJsonMetaBlocks = cleaned.replace(MARKER_JSON_BLOCK_RE, "");
+	strippedInjectedContext ||= afterJsonMetaBlocks !== cleaned;
+	cleaned = afterJsonMetaBlocks;
+	const afterChronologicalContext = stripLeadingChronologicalContextBlocks(cleaned);
+	strippedInjectedContext ||= afterChronologicalContext !== cleaned;
+	cleaned = afterChronologicalContext;
+	for (let pass = 0; pass < 16; pass += 1) {
+		const headerMatch = cleaned.match(MARKER_HEADER_LINE_RE);
+		if (headerMatch?.index === void 0) break;
+		const before = cleaned.slice(0, headerMatch.index);
+		if (before.trim().length > 0) {
+			cleaned = before;
+			break;
+		}
+		const lineEnd = cleaned.indexOf("\n");
+		const afterHeader = lineEnd === -1 ? "" : cleaned.slice(lineEnd + 1);
+		const afterPlainTextMetadata = afterHeader.trimStart().startsWith("```json") ? afterHeader : stripLeadingPlainTextMetadataBody(afterHeader);
+		strippedInjectedContext ||= afterPlainTextMetadata !== cleaned;
+		cleaned = afterPlainTextMetadata;
+	}
+	const afterActiveMemoryContext = cleaned.replace(/^Context:[ \t]*\n<active_memory_plugin>[\s\S]*?<\/active_memory_plugin>\s*/gm, "");
+	strippedInjectedContext ||= afterActiveMemoryContext !== cleaned;
+	cleaned = afterActiveMemoryContext;
+	const untrustedLineMatch = CONTEXT_HEADER_RE.exec(cleaned);
+	if (untrustedLineMatch) {
+		strippedInjectedContext = true;
+		cleaned = cleaned.slice(0, untrustedLineMatch.index);
+	}
+	cleaned = stripLeadingInboundEnvelope(cleaned, { allowAmbiguousMarkerFree: strippedInjectedContext });
+	cleaned = cleaned.replace(/<active_memory_plugin>[\s\S]*?<\/active_memory_plugin>/g, "");
+	cleaned = cleaned.replace(/\n{3,}/g, "\n\n").replace(/[ \t]{2,}/g, " ").trim();
+	return cleaned;
+}
+//#endregion
+export { dropMediaNoteLines, looksLikeEnvelopeSludge, sanitizeForMemoryCapture };

package/dist/memory-cli.js

@@ -0,0 +1,134 @@
+import { MEMORY_QUERY_COLUMNS } from "./lancedb-store.js";
+import { isMemoryMachineOutput } from "./cli-output-mode.js";
+import { normalizeRecallQuery } from "./memory-policy.js";
+import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
+import { defaultRuntime } from "openclaw/plugin-sdk/runtime";
+//#region extensions/memory-lancedb/memory-cli.ts
+function parsePositiveIntegerOption(value, flag) {
+	if (value === void 0) return;
+	const parsed = parseStrictPositiveInteger(value);
+	if (parsed === void 0) throw new Error(`${flag} must be a positive integer`);
+	return parsed;
+}
+function parseMemoryCliColumns(value) {
+	if (typeof value !== "string") return [...MEMORY_QUERY_COLUMNS];
+	const columns = value.split(",").map((column) => column.trim());
+	const invalid = columns.filter((column) => !MEMORY_QUERY_COLUMNS.includes(column));
+	if (invalid.length > 0) throw new Error(`Unsupported memory columns: ${invalid.join(", ")}`);
+	return columns;
+}
+function parseMemoryCliOrder(value) {
+	if (typeof value !== "string" || !value.trim()) return null;
+	const [column, direction = "asc", extra] = value.split(":");
+	if (extra !== void 0 || !MEMORY_QUERY_COLUMNS.includes(column) || !["asc", "desc"].includes(direction.toLowerCase())) throw new Error("--order-by must be <id|text|importance|category|createdAt>:<asc|desc>");
+	return {
+		column,
+		direction: direction.toLowerCase() === "desc" ? -1 : 1
+	};
+}
+function parseMemoryCliFilter(rawValue) {
+	if (rawValue === void 0) return;
+	if (typeof rawValue !== "string") throw new Error("--filter must be a string");
+	const filter = rawValue.trim();
+	if (filter.length > 200) throw new Error("Filter condition exceeds maximum length of 200 characters");
+	const match = /^(id|text|importance|category|createdAt)\s*(=|!=|<>|<=|>=|<|>|LIKE)\s*(?:'((?:''|[^'])*)'|(-?(?:\d+(?:\.\d+)?|\.\d+)))$/i.exec(filter);
+	if (!match) throw new Error("--filter must be one comparison using id, text, importance, category, or createdAt");
+	const rawColumn = match[1];
+	const rawOperator = match[2];
+	const rawString = match[3];
+	const rawNumber = match[4];
+	const column = MEMORY_QUERY_COLUMNS.find((candidate) => candidate.toLowerCase() === rawColumn.toLowerCase());
+	if (!column) throw new Error(`Unsupported memory filter column: ${rawColumn}`);
+	const operator = rawOperator.toUpperCase();
+	const value = rawString !== void 0 ? rawString.replaceAll("''", "'") : Number(rawNumber);
+	if (typeof value === "number" && !Number.isFinite(value)) throw new Error("--filter numeric value must be finite");
+	const expectsNumber = column === "importance" || column === "createdAt";
+	if (expectsNumber !== (typeof value === "number")) throw new Error(`--filter ${column} requires a ${expectsNumber ? "number" : "quoted string"}`);
+	if (operator === "LIKE" && typeof value !== "string") throw new Error("--filter LIKE requires a quoted string");
+	return {
+		column,
+		operator,
+		value
+	};
+}
+function registerMemoryCli(api, db, embeddings, resolveCliAgentId, recallMaxChars) {
+	api.registerCli(({ program }) => {
+		const memory = program.command("ltm").description("LanceDB memory plugin commands");
+		memory.command("list").description("List memories").option("--agent <id>", "Agent id (default: configured default agent)").option("--limit <n>", "Max results").option("--order-by-created-at", "Order memories by createdAt descending", false).action(async (opts) => {
+			const agentId = resolveCliAgentId(opts.agent);
+			const limit = parsePositiveIntegerOption(opts.limit, "--limit");
+			const entries = await db.list(agentId, limit, { orderByCreatedAt: Boolean(opts.orderByCreatedAt) });
+			defaultRuntime.writeJson(entries);
+		});
+		memory.command("search").description("Search memories").argument("<query>", "Search query").option("--agent <id>", "Agent id (default: configured default agent)").option("--limit <n>", "Max results", "5").action(async (query, opts) => {
+			let operationError;
+			let operationFailed = false;
+			try {
+				const agentId = resolveCliAgentId(opts.agent);
+				const vector = await embeddings.embed(normalizeRecallQuery(query, recallMaxChars));
+				const limit = parsePositiveIntegerOption(opts.limit, "--limit");
+				const output = (await db.search(agentId, vector, limit, .3)).map((r) => ({
+					id: r.entry.id,
+					text: r.entry.text,
+					category: r.entry.category,
+					importance: r.entry.importance,
+					score: r.score
+				}));
+				defaultRuntime.writeJson(output);
+			} catch (err) {
+				operationError = err;
+				operationFailed = true;
+			}
+			let closeError;
+			let closeFailed = false;
+			try {
+				await embeddings.close?.();
+			} catch (err) {
+				closeError = err;
+				closeFailed = true;
+			}
+			if (operationFailed) throw operationError;
+			if (closeFailed) throw closeError;
+		});
+		memory.command("query").description("Query memories (non-vector search)").option("--agent <id>", "Agent id (default: configured default agent)").option("--cols <columns>", "Columns to select, comma-separated").option("--filter <condition>", "Filter condition").option("--limit <n>", "Limit number of results", "10").option("--order-by <order>", "Order by column and direction (e.g., createdAt:desc)").action(async (opts) => {
+			const agentId = resolveCliAgentId(opts.agent);
+			const outputColumns = parseMemoryCliColumns(opts.cols);
+			const order = parseMemoryCliOrder(opts.orderBy);
+			const selectedColumns = [...outputColumns];
+			if (order && !selectedColumns.includes(order.column)) selectedColumns.push(order.column);
+			const limit = parsePositiveIntegerOption(opts.limit, "--limit") ?? 10;
+			let rows = await db.query(agentId, {
+				columns: selectedColumns,
+				filter: parseMemoryCliFilter(opts.filter),
+				...order ? {} : { limit }
+			});
+			if (order) {
+				rows.sort((a, b) => {
+					const aValue = a[order.column];
+					const bValue = b[order.column];
+					if (aValue < bValue) return -1 * order.direction;
+					if (aValue > bValue) return order.direction;
+					return 0;
+				});
+				rows = rows.slice(0, limit);
+				if (!outputColumns.includes(order.column)) for (const row of rows) delete row[order.column];
+			}
+			defaultRuntime.writeJson(rows);
+		});
+		memory.command("stats").description("Show memory statistics").option("--agent <id>", "Agent id (default: configured default agent)").action(async (opts) => {
+			const agentId = resolveCliAgentId(opts.agent);
+			const count = await db.count(agentId);
+			console.log(`Total memories: ${count}`);
+		});
+	}, {
+		commands: ["ltm"],
+		descriptors: [{
+			name: "ltm",
+			description: "LanceDB memory plugin commands",
+			hasSubcommands: true,
+			machineOutput: isMemoryMachineOutput
+		}]
+	});
+}
+//#endregion
+export { parseMemoryCliFilter, registerMemoryCli };