@alfe.ai/openclaw-memory-cloud 0.0.37 → 0.0.39

package/dist/plugin2.cjs

@@ -0,0 +1,1107 @@
+let node_module = require("node:module");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _sinclair_typebox = require("@sinclair/typebox");
+let _alfe_ai_config = require("@alfe.ai/config");
+let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
+let _alfe_ai_openclaw_plugin_kit = require("@alfe.ai/openclaw-plugin-kit");
+let node_fs = require("node:fs");
+let node_crypto = require("node:crypto");
+let node_os = require("node:os");
+//#region src/auto-capture.ts
+/**
+* Debounces and flushes live conversation capture independently per session.
+*
+* OpenClaw can interleave hooks from multiple sessions in one daemon process,
+* so a process-wide current session or queue is not safe. Every public method
+* therefore requires the canonical hook context session key.
+*/
+var AutoCapture = class AutoCapture {
+	static MAX_QUEUE_SIZE = 500;
+	sessions = /* @__PURE__ */ new Map();
+	/** Global per boot so evicting one session cannot reset its index sequence. */
+	messageIndex = 0;
+	constructor(client, config, logger, ingestEpoch) {
+		this.client = client;
+		this.config = config;
+		this.logger = logger;
+		this.ingestEpoch = ingestEpoch;
+	}
+	trackMessage(sessionKey, role, content, metadata) {
+		if (!this.config.autoCapture || content.length === 0) return;
+		const state = this.getSession(sessionKey);
+		if (metadata) state.metadata = mergeMetadata(state.metadata, metadata);
+		if (state.messages.length >= AutoCapture.MAX_QUEUE_SIZE) {
+			state.messages.shift();
+			this.logger.warn("Memory capture queue full; dropped oldest message", { queueSize: AutoCapture.MAX_QUEUE_SIZE });
+		}
+		state.messages.push({
+			role,
+			content: content.slice(0, this.config.captureMaxChars),
+			index: this.messageIndex++,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		this.resetTimer(sessionKey, state);
+	}
+	async flush(sessionKey) {
+		const state = this.sessions.get(sessionKey);
+		if (!state || state.messages.length === 0) return;
+		if (state.flushPromise) {
+			await state.flushPromise;
+			return;
+		}
+		state.flushPromise = this.flushSerially(sessionKey, state);
+		try {
+			await state.flushPromise;
+		} finally {
+			state.flushPromise = null;
+			if (state.messages.length === 0) this.deleteSession(sessionKey, state);
+		}
+	}
+	async onAgentEnd(sessionKey) {
+		const state = this.sessions.get(sessionKey);
+		if (!state) return;
+		this.clearTimer(state);
+		await this.flush(sessionKey);
+	}
+	destroy() {
+		for (const state of this.sessions.values()) this.clearTimer(state);
+		this.sessions.clear();
+	}
+	getSession(sessionKey) {
+		const existing = this.sessions.get(sessionKey);
+		if (existing) return existing;
+		const state = {
+			messages: [],
+			metadata: {},
+			timer: null,
+			flushPromise: null
+		};
+		this.sessions.set(sessionKey, state);
+		return state;
+	}
+	async flushSerially(sessionKey, state) {
+		while (state.messages.length > 0) {
+			const batch = state.messages.splice(0, state.messages.length);
+			if (batch.length === 0) return;
+			this.logger.debug("Flushing memory capture batch", { messageCount: batch.length });
+			try {
+				await this.client.memoryIngest(sessionKey, batch, state.metadata, this.ingestEpoch);
+			} catch {
+				state.messages.unshift(...batch);
+				this.logger.warn("Memory capture flush failed; retained batch for retry", { messageCount: batch.length });
+				return;
+			}
+		}
+	}
+	resetTimer(sessionKey, state) {
+		this.clearTimer(state);
+		state.timer = setTimeout(() => {
+			state.timer = null;
+			this.flush(sessionKey);
+		}, this.config.idleFlushSeconds * 1e3);
+		state.timer.unref();
+	}
+	clearTimer(state) {
+		if (state.timer) clearTimeout(state.timer);
+		state.timer = null;
+	}
+	deleteSession(sessionKey, state) {
+		this.clearTimer(state);
+		if (this.sessions.get(sessionKey) === state) this.sessions.delete(sessionKey);
+	}
+};
+function mergeMetadata(current, next) {
+	return {
+		...current.channelId ? { channelId: current.channelId } : {},
+		...current.userId ? { userId: current.userId } : {},
+		...current.userName ? { userName: current.userName } : {},
+		...next.channelId ? { channelId: next.channelId } : {},
+		...next.userId ? { userId: next.userId } : {},
+		...next.userName ? { userName: next.userName } : {}
+	};
+}
+//#endregion
+//#region src/file-boundary.ts
+const MAX_LEARN_TEXT_CHARS = 1e5;
+var WorkspaceFileError = class extends Error {
+	name = "WorkspaceFileError";
+};
+async function readWorkspaceText(workspacePath, relativePath) {
+	validateRelativePath(relativePath);
+	const workspaceReal = await (0, node_fs_promises.realpath)(workspacePath);
+	const requestedPath = (0, node_path.resolve)(workspaceReal, relativePath);
+	let componentPath = workspaceReal;
+	for (const component of relativePath.split("/")) {
+		componentPath = (0, node_path.join)(componentPath, component);
+		if ((await (0, node_fs_promises.lstat)(componentPath)).isSymbolicLink()) throw new WorkspaceFileError("Workspace path must not contain symlinks");
+	}
+	const requestedStat = await (0, node_fs_promises.lstat)(requestedPath);
+	if (requestedStat.isSymbolicLink() || !requestedStat.isFile()) throw new WorkspaceFileError("Workspace path must identify a regular file");
+	const fileReal = await (0, node_fs_promises.realpath)(requestedPath);
+	if (!isInside(workspaceReal, fileReal)) throw new WorkspaceFileError("Workspace path escapes the configured workspace");
+	let handle;
+	try {
+		handle = await (0, node_fs_promises.open)(fileReal, node_fs.constants.O_RDONLY | noFollowFlag$2());
+		const opened = await handle.stat();
+		if (!opened.isFile() || opened.size > 409600) throw new WorkspaceFileError("Workspace file exceeds the 400 KiB read limit");
+		const text = await handle.readFile("utf8");
+		if (text.length > 1e5) throw new WorkspaceFileError("Workspace file exceeds the 100,000 character learn limit");
+		return text;
+	} finally {
+		await handle?.close();
+	}
+}
+function validateRelativePath(value) {
+	if (typeof value !== "string" || value.length === 0 || value.length > 1024) throw new WorkspaceFileError("path must be a non-empty workspace-relative path");
+	if ((0, node_path.isAbsolute)(value) || value.includes("\\") || value.includes("//") || hasControlCharacters$1(value) || value.split("/").some((part) => part === "" || part === "." || part === "..")) throw new WorkspaceFileError("path must remain inside the configured workspace");
+}
+function hasControlCharacters$1(value) {
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+function isInside(root, candidate) {
+	const rel = (0, node_path.relative)(root, candidate);
+	return rel !== ".." && !rel.startsWith(`..${node_path.sep}`) && !(0, node_path.isAbsolute)(rel);
+}
+function noFollowFlag$2() {
+	return "O_NOFOLLOW" in node_fs.constants ? node_fs.constants.O_NOFOLLOW : 0;
+}
+//#endregion
+//#region src/boundary.ts
+const MAX_QUERY_CHARS = 4e3;
+const MAX_STORE_TEXT_CHARS = 5e3;
+const DEFAULT_CONFIG = {
+	autoCapture: true,
+	autoRecall: true,
+	captureMaxChars: 500,
+	idleFlushSeconds: 60,
+	backfillSessions: true,
+	backfillMaxSessions: 50
+};
+const TAGS = new Set([
+	"fact",
+	"decision",
+	"preference",
+	"event",
+	"discovery"
+]);
+var MemoryInputError = class extends Error {
+	name = "MemoryInputError";
+};
+function parseMemoryConfig(value) {
+	if (value === void 0) return { ...DEFAULT_CONFIG };
+	const input = record(value, "Memory plugin config");
+	rejectUnknown(input, [
+		"autoCapture",
+		"autoRecall",
+		"captureMaxChars",
+		"idleFlushSeconds",
+		"backfillSessions",
+		"backfillMaxSessions"
+	]);
+	return {
+		autoCapture: optionalBoolean(input.autoCapture, DEFAULT_CONFIG.autoCapture, "autoCapture"),
+		autoRecall: optionalBoolean(input.autoRecall, DEFAULT_CONFIG.autoRecall, "autoRecall"),
+		captureMaxChars: optionalInteger(input.captureMaxChars, DEFAULT_CONFIG.captureMaxChars, "captureMaxChars", 100, 1e4),
+		idleFlushSeconds: optionalInteger(input.idleFlushSeconds, DEFAULT_CONFIG.idleFlushSeconds, "idleFlushSeconds", 10, 600),
+		backfillSessions: optionalBoolean(input.backfillSessions, DEFAULT_CONFIG.backfillSessions, "backfillSessions"),
+		backfillMaxSessions: optionalInteger(input.backfillMaxSessions, DEFAULT_CONFIG.backfillMaxSessions, "backfillMaxSessions", 1, 1e3)
+	};
+}
+function parseSearchInput(value) {
+	const input = record(value, "Memory search parameters");
+	rejectUnknown(input, [
+		"query",
+		"limit",
+		"topic",
+		"subtopic",
+		"tag"
+	]);
+	return compact({
+		query: string(input.query, "query", 1, MAX_QUERY_CHARS, true),
+		limit: input.limit === void 0 ? 10 : integer(input.limit, "limit", 1, 50),
+		topic: optionalString(input.topic, "topic", 256),
+		subtopic: optionalString(input.subtopic, "subtopic", 256),
+		tag: optionalTag(input.tag)
+	});
+}
+function parseStoreInput(value) {
+	const input = record(value, "Memory store parameters");
+	rejectUnknown(input, [
+		"text",
+		"topic",
+		"subtopic",
+		"tag",
+		"importance"
+	]);
+	return compact({
+		text: string(input.text, "text", 1, MAX_STORE_TEXT_CHARS, true),
+		topic: optionalString(input.topic, "topic", 128),
+		subtopic: optionalString(input.subtopic, "subtopic", 128),
+		tag: optionalTag(input.tag),
+		importance: input.importance === void 0 ? void 0 : finite(input.importance, "importance", 0, 1)
+	});
+}
+function parseLearnInput(value) {
+	const input = record(value, "Memory learn parameters");
+	rejectUnknown(input, [
+		"content",
+		"path",
+		"source"
+	]);
+	const content = optionalString(input.content, "content", MAX_LEARN_TEXT_CHARS, true);
+	const path = optionalString(input.path, "path", 1024);
+	if (content === void 0 === (path === void 0)) throw new MemoryInputError("Provide exactly one of content or path");
+	if (path !== void 0) try {
+		validateRelativePath(path);
+	} catch {
+		throw new MemoryInputError("path must remain inside the configured workspace");
+	}
+	return compact({
+		content,
+		path,
+		source: optionalString(input.source, "source", 512)
+	});
+}
+function parseForgetInput(value) {
+	const input = record(value, "Memory forget parameters");
+	rejectUnknown(input, ["query", "confirmMemoryIds"]);
+	let confirmMemoryIds;
+	if (input.confirmMemoryIds !== void 0) {
+		if (!Array.isArray(input.confirmMemoryIds) || input.confirmMemoryIds.length < 1 || input.confirmMemoryIds.length > 5) throw new MemoryInputError("confirmMemoryIds must contain between 1 and 5 memory IDs");
+		confirmMemoryIds = input.confirmMemoryIds.map((id) => string(id, "memory ID", 1, 512));
+		if (new Set(confirmMemoryIds).size !== confirmMemoryIds.length) throw new MemoryInputError("confirmMemoryIds must not contain duplicates");
+	}
+	return compact({
+		query: string(input.query, "query", 1, MAX_QUERY_CHARS, true),
+		confirmMemoryIds
+	});
+}
+function parseEntityInput(value) {
+	const input = record(value, "Memory graph parameters");
+	rejectUnknown(input, ["entity"]);
+	return { entity: string(input.entity, "entity", 1, 512, true) };
+}
+function parseEmptyInput(value) {
+	rejectUnknown(record(value, "Tool parameters"), []);
+	return {};
+}
+function safeCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
+function safeText(value, maxChars) {
+	return typeof value === "string" ? value.slice(0, maxChars) : "";
+}
+function classifyToolFailure(error, action) {
+	if (error instanceof MemoryInputError) return error.message;
+	if (error instanceof Error && error.name === "WorkspaceFileError") return error.message;
+	return `${action} failed. Retry, and inspect agent diagnostics if the failure persists.`;
+}
+function record(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new MemoryInputError(`${label} must be an object`);
+	return value;
+}
+function rejectUnknown(input, allowed) {
+	const unknown = Object.keys(input).find((key) => !allowed.includes(key));
+	if (unknown) throw new MemoryInputError(`Unknown parameter: ${unknown}`);
+}
+function string(value, label, min, max, trim = false) {
+	if (typeof value !== "string") throw new MemoryInputError(`${label} must be a string`);
+	const result = trim ? value.trim() : value;
+	if (result.length < min || result.length > max || hasControlCharacters(result, true)) throw new MemoryInputError(`${label} must contain ${String(min)}-${String(max)} safe characters`);
+	return result;
+}
+function hasControlCharacters(value, allowTextWhitespace = false) {
+	for (const character of value) {
+		const code = character.charCodeAt(0);
+		if (code === 127) return true;
+		if (code < 32 && !(allowTextWhitespace && (code === 9 || code === 10 || code === 13))) return true;
+	}
+	return false;
+}
+function optionalString(value, label, max, trim = false) {
+	return value === void 0 ? void 0 : string(value, label, 1, max, trim);
+}
+function integer(value, label, min, max) {
+	if (!Number.isInteger(value) || value < min || value > max) throw new MemoryInputError(`${label} must be an integer from ${String(min)} to ${String(max)}`);
+	return value;
+}
+function optionalInteger(value, fallback, label, min, max) {
+	return value === void 0 ? fallback : integer(value, label, min, max);
+}
+function finite(value, label, min, max) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) throw new MemoryInputError(`${label} must be a finite number from ${String(min)} to ${String(max)}`);
+	return value;
+}
+function optionalBoolean(value, fallback, label) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "boolean") throw new MemoryInputError(`${label} must be a boolean`);
+	return value;
+}
+function optionalTag(value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || !TAGS.has(value)) throw new MemoryInputError("tag must be fact, decision, preference, event, or discovery");
+	return value;
+}
+function compact(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+//#endregion
+//#region src/formatter.ts
+const MAX_FACTS = 50;
+const MAX_MEMORIES = 50;
+const MAX_FIELD_CHARS = 512;
+const MAX_MEMORY_TEXT_CHARS = 2e3;
+function normalizeSearchResults(value) {
+	const input = isRecord$1(value) ? value : {};
+	const rawFacts = Array.isArray(input.facts) ? input.facts : [];
+	const rawMemories = Array.isArray(input.memories) ? input.memories : [];
+	return {
+		facts: rawFacts.slice(0, MAX_FACTS).filter(isRecord$1).map((fact) => ({
+			subject: safeText(fact.subject, MAX_FIELD_CHARS),
+			predicate: safeText(fact.predicate, MAX_FIELD_CHARS),
+			object: safeText(fact.object, MAX_MEMORY_TEXT_CHARS),
+			since: safeText(fact.since, 64),
+			confidence: safeFinite(fact.confidence)
+		})),
+		memories: rawMemories.slice(0, MAX_MEMORIES).filter(isRecord$1).map((memory) => ({
+			id: safeText(memory.id, MAX_FIELD_CHARS),
+			text: safeText(memory.text, MAX_MEMORY_TEXT_CHARS),
+			topic: safeText(memory.topic, MAX_FIELD_CHARS),
+			subtopic: safeText(memory.subtopic, MAX_FIELD_CHARS),
+			tag: safeText(memory.tag, 64),
+			importance: safeFinite(memory.importance),
+			timestamp: safeFinite(memory.timestamp),
+			score: safeFinite(memory.score)
+		})),
+		truncated: rawFacts.length > MAX_FACTS || rawMemories.length > MAX_MEMORIES
+	};
+}
+/** Format trusted, locally-normalized search results for tool display. */
+function formatSearchResults(results) {
+	return normalizeSearchResults(results);
+}
+/** Build prompt XML locally; the service-provided formatted field is ignored. */
+function formatMemoryContext(value) {
+	const input = isRecord$1(value) ? value : {};
+	const facts = Array.isArray(input.facts) ? input.facts.slice(0, 20).filter(isRecord$1) : [];
+	const memories = Array.isArray(input.memories) ? input.memories.slice(0, 5).filter(isRecord$1) : [];
+	if (facts.length === 0 && memories.length === 0) return void 0;
+	const lines = ["<relevant-memories>"];
+	if (facts.length > 0) {
+		lines.push("Known facts:");
+		for (const fact of facts) lines.push(`- ${escapeXml(safeText(fact.subject, 256))} ${escapeXml(safeText(fact.predicate, 256))} ${escapeXml(safeText(fact.object, 1e3))} (since ${escapeXml(safeText(fact.since, 64))})`);
+	}
+	if (memories.length > 0) {
+		lines.push("Related conversations:");
+		for (const memory of memories) lines.push(`- [${escapeXml(safeText(memory.topic, 256))}/${escapeXml(safeText(memory.subtopic, 256))}] ${escapeXml(safeText(memory.text, 2e3))}`);
+	}
+	lines.push("</relevant-memories>");
+	const xml = lines.join("\n");
+	return xml.length <= 16384 ? xml : void 0;
+}
+function escapeXml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function safeFinite(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+//#endregion
+//#region src/auto-recall.ts
+const RECALL_TIMEOUT_MS = 5e3;
+/**
+* Auto-recall loads tiered memory context at session start
+* and formats it for injection into the agent's prompt.
+*
+* Called from the before_agent_start hook.
+*/
+var AutoRecall = class {
+	constructor(client, config, logger) {
+		this.client = client;
+		this.config = config;
+		this.logger = logger;
+	}
+	/**
+	* Load memory context and return formatted XML for prompt injection.
+	* Returns prependContext string for the before_agent_start hook result.
+	*/
+	async loadForPrompt(userMessage) {
+		if (!this.config.autoRecall) return void 0;
+		try {
+			const topicHint = extractTopicHint(userMessage);
+			const tier = topicHint ? 2 : 1;
+			const context = await withTimeout(this.client.memoryLoadContext(tier, topicHint), RECALL_TIMEOUT_MS);
+			const formatted = formatMemoryContext(context);
+			if (!formatted) {
+				this.logger.debug("No relevant memories found for prompt");
+				return;
+			}
+			this.logger.debug("Loaded memory context for prompt", {
+				tier,
+				topicHint,
+				factCount: Array.isArray(context.facts) ? context.facts.length : 0,
+				memoryCount: Array.isArray(context.memories) ? context.memories.length : 0,
+				tokenEstimate: typeof context.tokenEstimate === "number" ? context.tokenEstimate : 0
+			});
+			return formatted;
+		} catch {
+			this.logger.warn("Failed to load bounded memory context");
+			return;
+		}
+	}
+};
+/**
+* Simple topic hint extraction from user message.
+* Returns the first capitalized word or proper noun as a potential topic.
+*/
+function extractTopicHint(message) {
+	const words = message.split(/\s+/);
+	for (let i = 1; i < words.length; i++) {
+		const word = words[i];
+		if (word && word.length > 2 && /^[A-Z]/.test(word) && !/^(The|And|But|For|With|This|That|What|How|Why|When|Where)$/.test(word)) return word.toLowerCase();
+	}
+}
+async function withTimeout(operation, timeoutMs) {
+	let timer;
+	const timeout = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error("Memory recall timed out"));
+		}, timeoutMs);
+		timer.unref();
+	});
+	try {
+		return await Promise.race([operation, timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/ingest-epoch.ts
+/** Strictly monotonic, crash-safe per-boot ingest epoch persistence. */
+const DEFAULT_EPOCH_FILE = (0, node_path.join)((0, node_os.homedir)(), ".alfe", "memory", "ingest-epoch.json");
+const MAX_STATE_BYTES = 128;
+function resolveIngestEpoch(opts = {}) {
+	const epochFile = opts.epochFile ?? DEFAULT_EPOCH_FILE;
+	const now = opts.now ?? Date.now();
+	if (!Number.isSafeInteger(now) || now < 0) throw new Error("Memory ingest epoch clock value is invalid");
+	const stateDir = (0, node_path.dirname)(epochFile);
+	(0, node_fs.mkdirSync)(stateDir, {
+		recursive: true,
+		mode: 448
+	});
+	const directoryStat = (0, node_fs.lstatSync)(stateDir);
+	if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) throw new Error("Memory ingest epoch directory is not a secure directory");
+	const last = readLastEpoch(epochFile);
+	if (last === Number.MAX_SAFE_INTEGER) throw new Error("Memory ingest epoch has reached its safe integer limit");
+	const epoch = Math.max(now, last + 1);
+	persistEpoch(epochFile, epoch);
+	return epoch;
+}
+function readLastEpoch(epochFile) {
+	try {
+		const target = (0, node_fs.lstatSync)(epochFile);
+		if (target.isSymbolicLink() || !target.isFile() || target.size > MAX_STATE_BYTES) throw new Error("Memory ingest epoch state file is unsafe");
+	} catch (error) {
+		if (error.code === "ENOENT") return 0;
+		throw error;
+	}
+	const fd = (0, node_fs.openSync)(epochFile, node_fs.constants.O_RDONLY | noFollowFlag$1());
+	try {
+		const opened = (0, node_fs.fstatSync)(fd);
+		if (!opened.isFile() || opened.size > MAX_STATE_BYTES) throw new Error("Memory ingest epoch state file is invalid");
+		const parsed = JSON.parse((0, node_fs.readFileSync)(fd, "utf8"));
+		const epoch = typeof parsed === "object" && parsed !== null ? parsed.epoch : void 0;
+		if (!Number.isSafeInteger(epoch) || epoch < 0) throw new Error("Memory ingest epoch state is corrupt");
+		return epoch;
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new Error("Memory ingest epoch state is corrupt");
+		throw error;
+	} finally {
+		(0, node_fs.closeSync)(fd);
+	}
+}
+function persistEpoch(epochFile, epoch) {
+	const temporary = (0, node_path.join)((0, node_path.dirname)(epochFile), `.${(0, node_path.basename)(epochFile)}.${String(process.pid)}.${(0, node_crypto.randomUUID)()}.tmp`);
+	let fd;
+	try {
+		fd = (0, node_fs.openSync)(temporary, node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY | noFollowFlag$1(), 384);
+		(0, node_fs.writeFileSync)(fd, `${JSON.stringify({ epoch })}\n`, "utf8");
+		(0, node_fs.fsyncSync)(fd);
+		(0, node_fs.closeSync)(fd);
+		fd = void 0;
+		(0, node_fs.renameSync)(temporary, epochFile);
+		(0, node_fs.chmodSync)(epochFile, 384);
+	} catch (error) {
+		if (fd !== void 0) (0, node_fs.closeSync)(fd);
+		try {
+			(0, node_fs.unlinkSync)(temporary);
+		} catch {}
+		throw error;
+	}
+}
+function noFollowFlag$1() {
+	return "O_NOFOLLOW" in node_fs.constants ? node_fs.constants.O_NOFOLLOW : 0;
+}
+//#endregion
+//#region src/session-backfill.ts
+/**
+* Session backfill — one-time ingestion of pre-existing chat history into
+* cloud memory, run fire-and-forget at plugin startup (see index.ts).
+*
+* Reads the openclaw-chat plugin's on-disk session files directly:
+*   ~/.alfe/sessions/chat/{sessionId}.json
+* The write side is packages/openclaw-chat/src/session-store.ts — that path
+* and file shape are a read contract; keep the two in sync. The chat plugin
+* is not a package dependency because its session-store functions aren't
+* part of its public entry and the plugin isn't guaranteed to be installed
+* alongside memory. Like the session store itself, this assumes one agent
+* per machine (`alfe remove` deletes ~/.alfe, so files never outlive the
+* agent they belong to).
+*
+* No-re-sync guarantees (in concert with services/memory):
+* 1. Runs only while the server-side `sessionsBackfillSyncedAt` flag is
+*    unset; the flag survives integration uninstall/reinstall.
+* 2. Only messages with timestamp < cutoffMs are ingested — for agents that
+*    already had memory installed, everything after `bootstrapSyncedAt` was
+*    already captured live by AutoCapture.
+* 3. sessionKey = file sessionId and index = file array position, so the
+*    ingest consumer's per-session `lastProcessedIndex` high-water mark makes
+*    a crash-and-retry replay free (filtered server-side before any cost).
+*
+* Each session is sent as exactly ONE memoryIngest call (one SQS message,
+* windowed to the most recent messages that fit the caps below). Splitting a
+* session across multiple SQS messages would race the shared per-session
+* high-water mark on the standard (non-FIFO) ingest queue: a transiently
+* failed early chunk redelivered after a later chunk succeeds gets filtered
+* out and silently lost.
+*/
+const DEFAULT_SESSIONS_DIR = (0, node_path.join)((0, node_os.homedir)(), ".alfe", "sessions", "chat");
+const MAX_MESSAGES_PER_SESSION = 500;
+const MAX_SESSION_KEY_CHARS = 256;
+const MAX_MESSAGE_INDEX = 1e6;
+const MAX_CONTENT_CHARS = 1e5;
+/** One ingest call becomes one SQS SendMessage (256KB hard limit). */
+const MAX_BATCH_BYTES = 18e4;
+const MAX_SESSION_FILES = 1e4;
+const MAX_SESSION_FILE_BYTES = 8 * 1024 * 1024;
+const MAX_METADATA_CHARS = 256;
+const MAX_DATE_MS = 864e13;
+async function runSessionsBackfill(client, config, logger, opts) {
+	const sessionsDir = opts.sessionsDir ?? DEFAULT_SESSIONS_DIR;
+	let fileNames;
+	try {
+		fileNames = (await (0, node_fs_promises.readdir)(sessionsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort().slice(0, MAX_SESSION_FILES);
+	} catch (err) {
+		if (err.code === "ENOENT") {
+			logger.debug("sessions backfill: no sessions directory, marking complete");
+			try {
+				await client.memoryBootstrapStatusMark("sessions");
+			} catch {}
+		} else logger.warn("sessions backfill: sessions directory unreadable; will retry on next startup");
+		return;
+	}
+	const sessions = [];
+	for (const name of fileNames) {
+		const parsed = await parseSessionFile((0, node_path.join)(sessionsDir, name), config.captureMaxChars, opts.cutoffMs);
+		if (parsed) sessions.push(parsed);
+	}
+	const eligible = sessions.filter((s) => s.messages.length > 0).sort((a, b) => b.lastMessageMs - a.lastMessageMs).slice(0, config.backfillMaxSessions);
+	if (eligible.length === 0) {
+		logger.debug("sessions backfill: no eligible sessions, marking complete");
+		try {
+			await client.memoryBootstrapStatusMark("sessions");
+		} catch {}
+		return;
+	}
+	logger.info("sessions backfill: ingesting sessions", {
+		sessionCount: eligible.length,
+		messageCount: eligible.reduce((n, s) => n + s.messages.length, 0)
+	});
+	for (const session of eligible) {
+		const metadata = {
+			...session.channel ? { channelId: session.channel } : {},
+			...session.userId ? { userId: session.userId } : {}
+		};
+		try {
+			await client.memoryIngest(session.sessionId, session.messages, metadata);
+		} catch {
+			logger.warn("sessions backfill: ingest failed; will retry on next startup");
+			return;
+		}
+	}
+	try {
+		await client.memoryBootstrapStatusMark("sessions");
+		logger.info("sessions backfill: complete", { sessionCount: eligible.length });
+	} catch {
+		logger.warn("sessions backfill: mark failed; will retry on next startup");
+	}
+}
+/**
+* Tolerant parse of a single session file. Returns null for corrupt or
+* shape-mismatched files (skipped, never fatal). Message `index` is the
+* original array position in the file — stable because the store is
+* append-only — so retries resume idempotently server-side.
+*/
+async function parseSessionFile(filePath, captureMaxChars, cutoffMs) {
+	let raw;
+	let handle;
+	try {
+		handle = await (0, node_fs_promises.open)(filePath, node_fs.constants.O_RDONLY | noFollowFlag());
+		const stat = await handle.stat();
+		if (!stat.isFile() || stat.size > MAX_SESSION_FILE_BYTES) return null;
+		raw = JSON.parse(await handle.readFile("utf8"));
+	} catch {
+		return null;
+	} finally {
+		await handle?.close();
+	}
+	if (typeof raw !== "object" || raw === null) return null;
+	const data = raw;
+	if (!isBoundedScalar(data.sessionId, MAX_SESSION_KEY_CHARS)) return null;
+	if (!Array.isArray(data.messages)) return null;
+	const maxContentChars = Math.min(captureMaxChars, MAX_CONTENT_CHARS);
+	let lastMessageMs = 0;
+	const filtered = [];
+	for (const [index, entry] of data.messages.entries()) {
+		if (index > MAX_MESSAGE_INDEX) break;
+		if (typeof entry !== "object" || entry === null) continue;
+		const msg = entry;
+		if (msg.role !== "user" && msg.role !== "assistant") continue;
+		if (typeof msg.content !== "string" || msg.content.trim().length === 0) continue;
+		if (typeof msg.timestamp !== "number" || !Number.isFinite(msg.timestamp) || msg.timestamp < 0 || msg.timestamp > MAX_DATE_MS) continue;
+		lastMessageMs = Math.max(lastMessageMs, msg.timestamp);
+		if (msg.timestamp >= cutoffMs) continue;
+		filtered.push({
+			role: msg.role,
+			content: msg.content.length > maxContentChars ? msg.content.slice(0, maxContentChars) : msg.content,
+			index,
+			timestamp: new Date(msg.timestamp).toISOString()
+		});
+	}
+	return {
+		sessionId: data.sessionId,
+		channel: isBoundedScalar(data.channel, MAX_METADATA_CHARS) ? data.channel : void 0,
+		userId: isBoundedScalar(data.userId, MAX_METADATA_CHARS) ? data.userId : void 0,
+		messages: recentWindow(filtered),
+		lastMessageMs
+	};
+}
+function isBoundedScalar(value, maxChars) {
+	return typeof value === "string" && value.length > 0 && value.length <= maxChars && !hasControlCharacters(value);
+}
+function noFollowFlag() {
+	return "O_NOFOLLOW" in node_fs.constants ? node_fs.constants.O_NOFOLLOW : 0;
+}
+/**
+* The most recent contiguous run of messages fitting both ingest caps
+* (message count and serialized bytes). Walks backwards from the newest
+* message and stops at the first one that would overflow the byte budget.
+*/
+function recentWindow(messages) {
+	const window = [];
+	let bytes = 0;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		if (window.length >= MAX_MESSAGES_PER_SESSION) break;
+		const msgBytes = Buffer.byteLength(JSON.stringify(messages[i])) + 1;
+		if (bytes + msgBytes > MAX_BATCH_BYTES) break;
+		window.unshift(messages[i]);
+		bytes += msgBytes;
+	}
+	return window;
+}
+//#endregion
+//#region src/runtime.ts
+const pkg = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
+const PLUGIN_VERSION = typeof pkg.version === "string" ? pkg.version : "0.0.0";
+const MAX_BOOTSTRAP_FILES = 200;
+const TAG_SCHEMA = _sinclair_typebox.Type.Union([
+	_sinclair_typebox.Type.Literal("fact"),
+	_sinclair_typebox.Type.Literal("decision"),
+	_sinclair_typebox.Type.Literal("preference"),
+	_sinclair_typebox.Type.Literal("event"),
+	_sinclair_typebox.Type.Literal("discovery")
+]);
+function createMemoryCloudPlugin(dependencies = {}) {
+	const resolveRuntimeConfig = dependencies.resolveConfig ?? _alfe_ai_config.resolveConfig;
+	const createClient = dependencies.createClient ?? ((config) => new _alfe_ai_agent_api_client.AgentApiClient(config));
+	const resolveEpoch = dependencies.resolveEpoch ?? resolveIngestEpoch;
+	const installErrorCapture = dependencies.installErrorCapture ?? _alfe_ai_agent_api_client.installToolErrorCapture;
+	return {
+		id: "@alfe.ai/openclaw-memory-cloud",
+		name: "Cloud Memory",
+		description: "Persistent agent memory backed by Turbopuffer and DynamoDB",
+		version: PLUGIN_VERSION,
+		kind: "memory",
+		register(api) {
+			installErrorCapture(api, { plugin: "openclaw-memory-cloud" });
+			const config = parseMemoryConfig(api.pluginConfig);
+			const state = {
+				client: null,
+				workspacePath: null,
+				capture: null
+			};
+			const ensureRuntime = () => {
+				if (state.client === null || state.workspacePath === null) {
+					const runtimeConfig = resolveRuntimeConfig();
+					state.client = createClient({
+						apiKey: runtimeConfig.apiKey,
+						apiUrl: runtimeConfig.apiUrl
+					});
+					state.workspacePath = runtimeConfig.workspacePath;
+				}
+				return {
+					client: state.client,
+					workspacePath: state.workspacePath
+				};
+			};
+			const captureApi = { memoryIngest: (...args) => ensureRuntime().client.memoryIngest(...args) };
+			const autoRecall = new AutoRecall({ memoryLoadContext: (...args) => ensureRuntime().client.memoryLoadContext(...args) }, config, api.logger);
+			const ensureCapture = () => {
+				if (!config.autoCapture || state.capture === false) return null;
+				if (state.capture === null) try {
+					state.capture = new AutoCapture(captureApi, config, api.logger, resolveEpoch());
+				} catch {
+					state.capture = false;
+					api.logger.warn("Memory auto-capture disabled because its monotonic epoch could not be secured");
+					return null;
+				}
+				return state.capture;
+			};
+			const runTool = async (action, operation) => {
+				try {
+					return await operation();
+				} catch (error) {
+					return {
+						status: "error",
+						error: classifyToolFailure(error, action)
+					};
+				}
+			};
+			api.registerMemoryPromptSection(({ availableTools }) => buildMemoryPrompt(availableTools));
+			api.registerTool((0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+				name: "memory_recall",
+				description: "Search private conversation memory and the per-agent knowledge graph.",
+				parameters: _sinclair_typebox.Type.Object({
+					query: _sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: MAX_QUERY_CHARS
+					}),
+					limit: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Integer({
+						minimum: 1,
+						maximum: 50,
+						default: 10
+					})),
+					topic: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ maxLength: 256 })),
+					subtopic: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ maxLength: 256 })),
+					tag: _sinclair_typebox.Type.Optional(TAG_SCHEMA)
+				}, { additionalProperties: false }),
+				handler: async (params) => runTool("Memory recall", async () => {
+					const input = parseSearchInput(params);
+					return formatSearchResults(await ensureRuntime().client.memorySearch(input.query, input));
+				})
+			}), { names: ["memory_recall", "memory_search"] });
+			api.registerTool((0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+				name: "memory_store",
+				description: "Explicitly save one bounded item to private long-term memory.",
+				parameters: _sinclair_typebox.Type.Object({
+					text: _sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: MAX_STORE_TEXT_CHARS
+					}),
+					topic: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ maxLength: 128 })),
+					subtopic: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ maxLength: 128 })),
+					tag: _sinclair_typebox.Type.Optional(TAG_SCHEMA),
+					importance: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Number({
+						minimum: 0,
+						maximum: 1
+					}))
+				}, { additionalProperties: false }),
+				handler: async (params) => runTool("Memory store", async () => {
+					const input = parseStoreInput(params);
+					const memoryId = safeText((await ensureRuntime().client.memoryStore(input.text, input)).memoryId, 512);
+					if (!memoryId) throw new Error("Memory store response omitted the memory ID");
+					return {
+						status: "stored",
+						memoryId
+					};
+				})
+			}), { names: ["memory_store"] });
+			api.registerTool((0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+				name: "memory_learn",
+				description: "Ingest bounded inline text or one regular file inside the configured agent workspace.",
+				parameters: _sinclair_typebox.Type.Object({
+					content: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: 1e5
+					})),
+					path: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: 1024
+					})),
+					source: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: 512
+					}))
+				}, { additionalProperties: false }),
+				handler: async (params) => runTool("Memory learn", async () => {
+					const input = parseLearnInput(params);
+					const runtime = ensureRuntime();
+					let text;
+					if (input.path === void 0) {
+						if (input.content === void 0) throw new Error("Memory learn content is unavailable");
+						text = input.content;
+					} else text = await readWorkspaceText(runtime.workspacePath, input.path);
+					const result = await runtime.client.memoryLearn({
+						text,
+						source: input.source ?? input.path,
+						sourceType: input.path === void 0 ? "inline" : "file"
+					});
+					return {
+						status: "stored",
+						memoriesStored: safeCount(result.memoriesStored),
+						triplesStored: safeCount(result.triplesStored),
+						chunks: safeCount(result.chunks)
+					};
+				})
+			}), { names: ["memory_learn"] });
+			api.registerTool((0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+				name: "memory_forget",
+				description: "Preview up to five matching private memories, then delete only after confirming the exact returned IDs.",
+				parameters: _sinclair_typebox.Type.Object({
+					query: _sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: MAX_QUERY_CHARS
+					}),
+					confirmMemoryIds: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Array(_sinclair_typebox.Type.String({
+						minLength: 1,
+						maxLength: 512
+					}), {
+						minItems: 1,
+						maxItems: 5,
+						uniqueItems: true
+					}))
+				}, { additionalProperties: false }),
+				handler: async (params) => runTool("Memory deletion", async () => {
+					const input = parseForgetInput(params);
+					const client = ensureRuntime().client;
+					const matches = normalizeSearchResults(await client.memorySearch(input.query, { limit: 5 })).memories.slice(0, 5).filter((memory) => memory.id.length > 0);
+					const currentIds = matches.map((memory) => memory.id);
+					if (input.confirmMemoryIds === void 0) return {
+						status: "confirmation_required",
+						matches: matches.map((memory) => ({
+							id: memory.id,
+							text: memory.text.slice(0, 240)
+						})),
+						instruction: "Call memory_forget again with confirmMemoryIds exactly as returned, in the same order."
+					};
+					if (JSON.stringify(input.confirmMemoryIds) !== JSON.stringify(currentIds)) return {
+						status: "error",
+						error: "Matching memories changed; preview again before deleting."
+					};
+					const deletedIds = [];
+					const failedIds = [];
+					for (const memoryId of currentIds) try {
+						if ((await client.memoryDelete(memoryId)).deleted) deletedIds.push(memoryId);
+						else failedIds.push(memoryId);
+					} catch {
+						failedIds.push(memoryId);
+					}
+					return failedIds.length === 0 ? {
+						status: "deleted",
+						deletedIds
+					} : {
+						status: "error",
+						error: "Some memories could not be deleted.",
+						deletedIds,
+						failedIds
+					};
+				})
+			}), { names: ["memory_forget"] });
+			api.registerTool((0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+				name: "memory_graph",
+				description: "Look up bounded facts about one entity in the private knowledge graph.",
+				parameters: _sinclair_typebox.Type.Object({ entity: _sinclair_typebox.Type.String({
+					minLength: 1,
+					maxLength: 512
+				}) }, { additionalProperties: false }),
+				handler: async (params) => runTool("Memory graph lookup", async () => {
+					const { entity } = parseEntityInput(params);
+					const result = await ensureRuntime().client.memoryLookupEntity(entity);
+					const triples = Array.isArray(result.triples) ? result.triples.slice(0, 100) : [];
+					return {
+						subject: safeText(result.subject, 512),
+						triples: triples.map((triple) => ({
+							predicate: safeText(triple.predicate, 512),
+							object: safeText(triple.object, 2e3),
+							validFrom: safeText(triple.validFrom, 64),
+							confidence: typeof triple.confidence === "number" && Number.isFinite(triple.confidence) ? triple.confidence : 0
+						})),
+						truncated: Array.isArray(result.triples) && result.triples.length > 100
+					};
+				})
+			}), { names: ["memory_graph"] });
+			api.registerTool((0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+				name: "memory_stats",
+				description: "Get bounded private-memory storage statistics.",
+				parameters: _sinclair_typebox.Type.Object({}, { additionalProperties: false }),
+				handler: async (params) => runTool("Memory stats", async () => {
+					parseEmptyInput(params);
+					const stats = await ensureRuntime().client.memoryStats();
+					return {
+						vectorCount: safeCount(stats.vectorCount),
+						tripleCount: safeCount(stats.tripleCount),
+						storageEstimateBytes: safeCount(stats.storageEstimateBytes)
+					};
+				})
+			}), { names: ["memory_stats"] });
+			api.registerTool((0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+				name: "memory_navigate",
+				description: "Browse bounded topic and subtopic counts in private memory.",
+				parameters: _sinclair_typebox.Type.Object({}, { additionalProperties: false }),
+				handler: async (params) => runTool("Memory navigation", async () => {
+					parseEmptyInput(params);
+					const result = await ensureRuntime().client.memoryNavigate();
+					return {
+						topics: (Array.isArray(result.topics) ? result.topics.slice(0, 200) : []).map((topic) => ({
+							name: safeText(topic.name, 256),
+							tripleCount: safeCount(topic.tripleCount),
+							subtopics: Array.isArray(topic.subtopics) ? topic.subtopics.slice(0, 100).map((entry) => safeText(entry, 256)) : []
+						})),
+						truncated: Array.isArray(result.topics) && result.topics.length > 200
+					};
+				})
+			}), { names: ["memory_navigate"] });
+			api.on("before_agent_start", async (event) => {
+				const prompt = isRecord(event) && typeof event.prompt === "string" ? event.prompt : "";
+				const contextXml = await autoRecall.loadForPrompt(prompt.slice(0, MAX_QUERY_CHARS));
+				return contextXml ? { prependContext: contextXml } : void 0;
+			}, { priority: 10 });
+			api.on("message_received", (event, context) => {
+				trackHookMessage(ensureCapture(), "user", event, context);
+			});
+			api.on("message_sending", (event, context) => {
+				trackHookMessage(ensureCapture(), "assistant", event, context);
+			});
+			api.on("agent_end", async (event, context) => {
+				if (isRecord(event) && event.success === false) return;
+				const sessionKey = hookSessionKey(context);
+				if (sessionKey) await ensureCapture()?.onAgentEnd(sessionKey);
+			});
+			Promise.resolve().then(async () => {
+				const runtime = ensureRuntime();
+				await runStartupSync(runtime.client, runtime.workspacePath, config, api.logger);
+			}).catch(() => {
+				api.logger.warn("Memory startup sync failed; it will retry on next startup");
+			});
+			api.logger.info("memory-cloud extension registered", {
+				autoCapture: config.autoCapture,
+				autoRecall: config.autoRecall
+			});
+		}
+	};
+}
+function trackHookMessage(capture, role, event, context) {
+	if (!capture || !isRecord(event)) return;
+	const sessionKey = hookSessionKey(context);
+	const content = typeof event.content === "string" ? event.content : "";
+	if (!sessionKey || content.length === 0) return;
+	capture.trackMessage(sessionKey, role, content, hookMetadata(context));
+}
+function hookSessionKey(context) {
+	if (!isRecord(context) || typeof context.sessionKey !== "string") return void 0;
+	const value = context.sessionKey;
+	return value.length > 0 && value.length <= 256 && !hasControlCharacters(value) ? value : void 0;
+}
+function hookMetadata(context) {
+	if (!isRecord(context)) return void 0;
+	const channelId = safeOptionalScalar(context.channelId);
+	const userId = safeOptionalScalar(context.userId);
+	return channelId || userId ? {
+		...channelId ? { channelId } : {},
+		...userId ? { userId } : {}
+	} : void 0;
+}
+function safeOptionalScalar(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= 256 && !hasControlCharacters(value) ? value : void 0;
+}
+function buildMemoryPrompt(availableTools) {
+	const lines = ["## Memory"];
+	if (availableTools.has("memory_recall")) lines.push("Use memory_recall to search private conversation memory and per-agent facts.");
+	if (availableTools.has("memory_store")) lines.push("Use memory_store for an explicit bounded item worth retaining.");
+	if (availableTools.has("memory_learn")) lines.push("Use memory_learn for bounded source text or a regular file inside the configured workspace.");
+	if (availableTools.has("memory_graph")) lines.push("Use memory_graph to look up facts about one entity.");
+	if (availableTools.has("memory_forget")) lines.push("memory_forget always requires a preview followed by exact ID confirmation.");
+	return lines;
+}
+async function runStartupSync(client, workspacePath, config, logger) {
+	let status;
+	try {
+		status = await client.memoryBootstrapStatus();
+	} catch {
+		logger.debug("Memory bootstrap status check failed; startup sync skipped");
+		return;
+	}
+	const startupMs = Date.now();
+	if (!status.synced && !await runBootstrap(client, workspacePath, logger)) return;
+	if (config.backfillSessions && status.sessionsBackfillSynced === false) {
+		const installedAtMs = status.syncedAt ? Date.parse(status.syncedAt) : Number.POSITIVE_INFINITY;
+		await runSessionsBackfill(client, config, logger, { cutoffMs: Math.min(startupMs, Number.isFinite(installedAtMs) ? installedAtMs : Number.POSITIVE_INFINITY) });
+	}
+}
+async function runBootstrap(client, workspacePath, logger) {
+	const relativePaths = [];
+	try {
+		const stat = await (0, node_fs_promises.lstat)((0, node_path.join)(workspacePath, "MEMORY.md"));
+		if (stat.isFile() && !stat.isSymbolicLink()) relativePaths.push("MEMORY.md");
+	} catch {}
+	try {
+		const memoryDirectory = (0, node_path.join)(workspacePath, "memory");
+		const stat = await (0, node_fs_promises.lstat)(memoryDirectory);
+		if (stat.isDirectory() && !stat.isSymbolicLink()) {
+			const entries = await (0, node_fs_promises.readdir)(memoryDirectory, { withFileTypes: true });
+			for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+				if (relativePaths.length >= MAX_BOOTSTRAP_FILES) break;
+				if (entry.isFile() && entry.name.endsWith(".md")) relativePaths.push(`memory/${entry.name}`);
+			}
+		}
+	} catch {}
+	for (const relativePath of relativePaths) try {
+		const text = await readWorkspaceText(workspacePath, relativePath);
+		if (text.trim().length > 0) await client.memoryLearn({
+			text,
+			source: relativePath,
+			sourceType: "file"
+		});
+	} catch {
+		logger.warn("Memory bootstrap file ingestion failed; it will retry on next startup");
+		return false;
+	}
+	try {
+		await client.memoryBootstrapStatusMark();
+		logger.info("Memory workspace bootstrap complete", { fileCount: relativePaths.length });
+		return true;
+	} catch {
+		logger.warn("Memory bootstrap completion mark failed; it will retry on next startup");
+		return false;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/plugin.ts
+const plugin = createMemoryCloudPlugin();
+//#endregion
+Object.defineProperty(exports, "plugin", {
+	enumerable: true,
+	get: function() {
+		return plugin;
+	}
+});