@agentmemory/agentmemory 0.9.30 → 0.9.32

package/dist/{standalone-DKCdrf1d.mjs → standalone-BYo5USDb.mjs}

@@ -1,7 +1,9 @@
-import { o as generateId } from "./keyed-mutex-DchXsyfP.mjs";
-import { A as getStandalonePersistPath, _ as VERSION, i as resolveClientSecret, m as getAllTools, s as queryAudit } from "./secret-store-BnY3A50C.mjs";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { s as generateId } from "./keyed-mutex-DCUh7PG-.mjs";
+import { $ as getStandalonePersistPath, C as getAllTools, E as VERSION, H as getAgentId, P as redactCredentialUrls, at as isAgentScopeIsolated, c as memoryToObservation, f as isSearchLayer, g as queryAudit, i as resolveClientSecret, o as buildRecallResponse } from "./secret-store-iYXRcrO8.mjs";
+import { a as pageAfterCursor, c as sortByKeyDesc, n as parseSearchExpansionIds, t as parseSessionArguments } from "./session-arguments-zxsbbd8y.mjs";
+import { chmodSync, closeSync, existsSync, fchmodSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir, tmpdir } from "node:os";
 //#region src/mcp/in-memory-kv.ts
 var InMemoryKV = class {
 	store = /* @__PURE__ */ new Map();
@@ -32,20 +34,35 @@ var InMemoryKV = class {
 		return entries ? Array.from(entries.values()) : [];
 	}
 	persist() {
-		if (!this.persistPath) return;
+		if (!this.persistPath) return false;
 		try {
 			const dir = dirname(this.persistPath);
 			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 			const data = {};
 			for (const [scope, entries] of this.store) data[scope] = Object.fromEntries(entries);
-			writeFileSync(this.persistPath, JSON.stringify(data), "utf-8");
+			const tmpPath = `${this.persistPath}.${process.pid}.tmp`;
+			try {
+				writeFileSync(tmpPath, JSON.stringify(data), {
+					encoding: "utf-8",
+					mode: 384
+				});
+				renameSync(tmpPath, this.persistPath);
+			} catch (err) {
+				try {
+					rmSync(tmpPath, { force: true });
+				} catch {}
+				throw err;
+			}
+			return true;
 		} catch (err) {
 			process.stderr.write(`[@agentmemory/mcp] Persist failed: ${err instanceof Error ? err.message : String(err)}\n`);
+			return false;
 		}
 	}
 };
 //#endregion
 //#region src/mcp/transport.ts
+let activeStdioTransports = 0;
 var JsonRpcError = class extends Error {
 	constructor(code, message) {
 		super(message);
@@ -198,6 +215,7 @@ function createMessageParser(onMessage, writeErr = (msg) => process.stderr.write
 function createStdioTransport(handler) {
 	let parser = null;
 	let queue = Promise.resolve();
+	let active = false;
 	const writeResponse = (response) => {
 		const formatted = formatResponse(response, parser?.isFramed() ?? false);
 		if (typeof formatted === "string") {
@@ -209,6 +227,10 @@ function createStdioTransport(handler) {
 	const onData = (chunk) => parser?.push(chunk);
 	return {
 		start() {
+			if (active) return;
+			active = true;
+			activeStdioTransports += 1;
+			process.env["AGENTMEMORY_MCP_STDIO__"] = "1";
 			parser = createMessageParser((message) => {
 				queue = queue.then(() => processLine(message, handler, writeResponse));
 				queue.catch((err) => {
@@ -219,10 +241,161 @@ function createStdioTransport(handler) {
 		},
 		stop() {
 			process.stdin.off("data", onData);
+			if (active) {
+				active = false;
+				activeStdioTransports -= 1;
+				if (activeStdioTransports === 0) delete process.env["AGENTMEMORY_MCP_STDIO__"];
+			}
 			parser = null;
 		}
 	};
 }
+const MAX_CRASH_LINE_BYTES = 64 * 1024;
+function writeStderr(text) {
+	process.stderr.write(text);
+}
+function stderrWriteMayBlock(platform = process.platform, isTTY = process.stderr.isTTY) {
+	return platform === "win32" && !isTTY;
+}
+function mcpCrashLogPath(env = process.env) {
+	return join(env["AGENTMEMORY_DATA_DIR"] || join(homedir(), ".agentmemory"), "mcp-crash.log");
+}
+function formatFatal(kind, reason, now = /* @__PURE__ */ new Date()) {
+	const detail = reason instanceof Error ? reason.stack || reason.message : String(reason);
+	return redactCredentialUrls(`[${now.toISOString()}] pid=${process.pid} ${kind}: ${detail}\n`);
+}
+function safeFormat(kind, reason) {
+	try {
+		return formatFatal(kind, reason);
+	} catch {
+		return `[${(/* @__PURE__ */ new Date()).toISOString()}] pid=${process.pid} ${kind}: (the error could not be formatted)\n`;
+	}
+}
+function describe(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function rotateCrashLog(logPath, notices) {
+	const rotated = `${logPath}.1`;
+	try {
+		renameSync(logPath, rotated);
+	} catch (err) {
+		if (err.code === "ENOENT") return;
+		throw err;
+	}
+	try {
+		chmodSync(rotated, 384);
+	} catch (err) {
+		notices.push(`[@agentmemory/mcp] rotated crash log ${rotated} could not be made owner-only: ${describe(err)}\n`);
+	}
+}
+function boundCrashLine(line, maxBytes = MAX_CRASH_LINE_BYTES) {
+	const bytes = Buffer.from(line, "utf8");
+	if (bytes.length <= maxBytes) return line;
+	const marker = " ...(truncated)\n";
+	const markerBytes = Buffer.byteLength(marker);
+	if (maxBytes <= markerBytes) return bytes.subarray(0, Math.max(0, maxBytes)).toString("utf8").replace(/�+$/, "");
+	return `${bytes.subarray(0, maxBytes - markerBytes).toString("utf8").replace(/�+$/, "")}${marker}`;
+}
+function writeAll(fd, data, write = writeSync) {
+	let offset = 0;
+	while (offset < data.length) {
+		const n = write(fd, data, offset, data.length - offset);
+		if (!(n > 0)) throw new Error(`crash log write stopped after ${offset} of ${data.length} bytes`);
+		offset += n;
+	}
+}
+function writeCrashLog(line, logPath = mcpCrashLogPath()) {
+	const notices = [];
+	const bounded = boundCrashLine(line);
+	let fd;
+	try {
+		mkdirSync(dirname(logPath), {
+			recursive: true,
+			mode: 448
+		});
+		if (existsSync(logPath) && statSync(logPath).size + Buffer.byteLength(bounded) > 1048576) rotateCrashLog(logPath, notices);
+		fd = openSync(logPath, "a", 384);
+		try {
+			fchmodSync(fd, 384);
+		} catch (err) {
+			notices.push(`[@agentmemory/mcp] crash log ${logPath} could not be made owner-only, so it was not written: ${describe(err)}\n`);
+			return {
+				written: false,
+				notices
+			};
+		}
+		writeAll(fd, Buffer.from(bounded, "utf8"));
+		notices.push(`[@agentmemory/mcp] crash log: ${logPath}\n`);
+		return {
+			written: true,
+			notices
+		};
+	} catch (err) {
+		notices.push(`[@agentmemory/mcp] crash log not written to ${logPath}: ${describe(err)}\n`);
+		return {
+			written: false,
+			notices
+		};
+	} finally {
+		if (fd !== void 0) try {
+			closeSync(fd);
+		} catch {}
+	}
+}
+function fallbackCrashLogPath() {
+	return join(tmpdir(), "agentmemory-mcp-crash.log");
+}
+function handleFatal(kind, reason, hooks) {
+	const line = safeFormat(kind, reason);
+	const stderrMayBlock = hooks.stderrMayBlock ?? stderrWriteMayBlock();
+	let result = {
+		written: false,
+		notices: []
+	};
+	try {
+		result = writeCrashLog(line, hooks.logPath ?? mcpCrashLogPath());
+	} catch {}
+	const notices = result.notices;
+	if (!result.written && stderrMayBlock) try {
+		writeCrashLog(line + notices.join(""), hooks.fallbackLogPath ?? fallbackCrashLogPath());
+	} catch {}
+	try {
+		hooks.persist();
+	} catch {}
+	if (!stderrMayBlock) {
+		const write = hooks.write ?? writeStderr;
+		for (const text of [`[@agentmemory/mcp] fatal ${line}`, ...notices]) try {
+			write(text);
+		} catch {}
+	}
+	(hooks.exit ?? ((code) => process.exit(code)))(1);
+}
+function installCrashHandlers(hooks) {
+	process.on("uncaughtException", (err) => handleFatal("uncaughtException", err, hooks));
+	process.on("unhandledRejection", (reason) => handleFatal("unhandledRejection", reason, hooks));
+}
+//#endregion
+//#region src/hooks/_endpoint.ts
+const OPTION_PREFIX = "CLAUDE_PLUGIN_OPTION_";
+function filled(value) {
+	const trimmed = value?.trim();
+	if (!trimmed || trimmed.startsWith("${") && trimmed.endsWith("}")) return void 0;
+	return value;
+}
+function hookSetting(name, env = process.env) {
+	const optionKey = `${OPTION_PREFIX}${name}`;
+	const option = filled(env[optionKey])?.trim();
+	if (option) return option;
+	if (name === "AGENTMEMORY_SECRET" && optionKey in env) return void 0;
+	return filled(env[name]);
+}
+function resolveSettingSecret(url, env = process.env) {
+	const secretEnv = { ...env };
+	const explicit = hookSetting("AGENTMEMORY_SECRET", env);
+	if (explicit === void 0) delete secretEnv["AGENTMEMORY_SECRET"];
+	else secretEnv["AGENTMEMORY_SECRET"] = explicit;
+	return resolveClientSecret(url, secretEnv);
+}
 //#endregion
 //#region src/mcp/rest-proxy.ts
 const DEFAULT_URL = "http://localhost:3111";
@@ -235,7 +408,7 @@ function probeTimeoutMs() {
 	const n = Number(raw);
 	return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_HEALTH_PROBE_TIMEOUT_MS;
 }
-function forceProxy() {
+function isProxyRequired() {
 	const raw = process.env["AGENTMEMORY_FORCE_PROXY"];
 	return raw === "1" || raw === "true";
 }
@@ -250,26 +423,32 @@ var ProxyCallError = class extends Error {
 	}
 };
 let cached = null;
+let cachedUrl = null;
 let cachedAt = 0;
 let probeInFlight = null;
 function resolveEnvOrEmpty(name) {
-	const raw = process.env[name];
-	if (!raw) return "";
-	if (raw.startsWith("${") && raw.endsWith("}")) return "";
-	return raw;
+	return hookSetting(name) ?? "";
 }
 function baseUrl() {
-	return (resolveEnvOrEmpty("AGENTMEMORY_URL") || DEFAULT_URL).replace(/\/+$/, "");
+	const value = resolveEnvOrEmpty("AGENTMEMORY_URL") || DEFAULT_URL;
+	try {
+		const parsed = new URL(value);
+		if (!["http:", "https:"].includes(parsed.protocol) || !parsed.hostname || parsed.username || parsed.password || /[?#\s]/.test(value)) throw new Error();
+		return value.replace(/\/+$/, "");
+	} catch {
+		throw new Error("AGENTMEMORY_URL must be an HTTP(S) URL without credentials, query, or fragment");
+	}
 }
-function authHeader() {
-	const secret = resolveClientSecret(baseUrl());
+function authHeader(url) {
+	const secret = resolveSettingSecret(url);
 	return secret ? { authorization: `Bearer ${secret}` } : {};
 }
 const defaultLivezProbe = async (url, timeoutMs, headers) => {
 	const res = await fetch(`${url}/agentmemory/livez`, {
 		method: "GET",
 		headers,
-		signal: AbortSignal.timeout(timeoutMs)
+		signal: AbortSignal.timeout(timeoutMs),
+		redirect: "error"
 	});
 	return {
 		ok: res.ok,
@@ -281,7 +460,7 @@ let livezProbe = defaultLivezProbe;
 async function probe(url) {
 	const timeout = probeTimeoutMs();
 	try {
-		const res = await livezProbe(url, timeout, authHeader());
+		const res = await livezProbe(url, timeout, authHeader(url));
 		if (!res.ok) process.stderr.write(`[@agentmemory/mcp] livez probe ${url}/agentmemory/livez -> ${res.status ?? "?"} ${res.statusText ?? ""}; falling back to local InMemoryKV (set AGENTMEMORY_FORCE_PROXY=1 to skip the probe)\n`);
 		return res.ok;
 	} catch (err) {
@@ -291,33 +470,38 @@ async function probe(url) {
 }
 function invalidateHandle() {
 	cached = null;
+	cachedUrl = null;
 	cachedAt = 0;
 }
 async function resolveHandle() {
 	const now = Date.now();
+	const url = baseUrl();
+	if (cached && (cachedUrl !== url || cached.mode === "local" && isProxyRequired())) invalidateHandle();
 	if (cached) if (cached.mode === "local" && now - cachedAt >= LOCAL_MODE_TTL_MS) {
 		cached = null;
 		cachedAt = 0;
 	} else return cached;
-	if (probeInFlight) return probeInFlight;
-	const url = baseUrl();
-	const skipProbe = forceProxy();
-	probeInFlight = (async () => {
+	const skipProbe = isProxyRequired();
+	if (probeInFlight?.url === url && probeInFlight.forceProxy === skipProbe) return probeInFlight.promise;
+	const pending = (async () => {
 		const up = skipProbe ? true : await probe(url);
+		if (baseUrl() !== url || isProxyRequired() !== skipProbe) return resolveHandle();
 		if (skipProbe) process.stderr.write(`[@agentmemory/mcp] AGENTMEMORY_FORCE_PROXY set; skipping livez probe and trusting ${url}\n`);
 		if (up) {
 			const handle = {
 				mode: "proxy",
 				baseUrl: url,
 				call: async (path, init) => {
+					if (baseUrl() !== url) throw new Error("AgentMemory endpoint changed; resolve a new proxy handle before retrying.");
 					const res = await fetch(`${url}${path}`, {
 						...init,
 						headers: {
 							"content-type": "application/json",
-							...authHeader(),
+							...authHeader(url),
 							...init?.headers
 						},
-						signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
+						signal: AbortSignal.timeout(CALL_TIMEOUT_MS),
+						redirect: "error"
 					});
 					if (!res.ok) {
 						const errText = await res.text().catch(() => "");
@@ -334,18 +518,25 @@ async function resolveHandle() {
 				}
 			};
 			cached = handle;
+			cachedUrl = url;
 			cachedAt = Date.now();
 			return handle;
 		}
 		const local = { mode: "local" };
 		cached = local;
+		cachedUrl = url;
 		cachedAt = Date.now();
 		return local;
 	})();
+	probeInFlight = {
+		url,
+		forceProxy: skipProbe,
+		promise: pending
+	};
 	try {
-		return await probeInFlight;
+		return await pending;
 	} finally {
-		probeInFlight = null;
+		if (probeInFlight?.promise === pending) probeInFlight = null;
 	}
 }
 //#endregion
@@ -405,6 +596,9 @@ function textResponse(payload, pretty = false) {
 		text: JSON.stringify(payload, null, pretty ? 2 : 0)
 	}] };
 }
+function isAuthenticationError(error) {
+	return error instanceof ProxyCallError && (error.status === 401 || error.status === 403);
+}
 function validate(toolName, args) {
 	if (!IMPLEMENTED_TOOLS.has(toolName)) throw new Error(`Unknown tool: ${toolName}`);
 	const v = { tool: toolName };
@@ -422,22 +616,41 @@ function validate(toolName, args) {
 		}
 		case "memory_recall":
 		case "memory_smart_search": {
+			if (args.targetLayer !== void 0 && !isSearchLayer(args.targetLayer)) throw new Error("targetLayer must be one of: all, memory, observation");
+			v.targetLayer = args.targetLayer ?? "all";
+			for (const field of [
+				"project",
+				"cwd",
+				"agentId",
+				"sessionId",
+				"source"
+			]) {
+				if (args[field] !== void 0 && typeof args[field] !== "string") throw new Error(`${field} must be a string`);
+				if (typeof args[field] === "string" && args[field].trim()) v[field] = args[field].trim();
+			}
+			if (toolName === "memory_smart_search") {
+				v.expandIds = parseSearchExpansionIds(args.expandIds);
+				if (typeof args.includeLessons === "boolean") v.includeLessons = args.includeLessons;
+			}
 			const query = args["query"];
-			if (typeof query !== "string" || !query.trim()) throw new Error("query is required");
-			v.query = query.trim();
+			if (typeof query !== "string" || !query.trim()) {
+				if (!v.expandIds?.length) throw new Error("query is required unless expandIds is provided");
+			} else v.query = query.trim();
 			v.limit = parseLimit(args["limit"]);
-			const fmt = args["format"];
-			if (typeof fmt === "string" && fmt.trim()) v.format = fmt.trim().toLowerCase();
-			const budget = args["token_budget"];
-			if (typeof budget === "number" && Number.isFinite(budget) && budget > 0) v.tokenBudget = Math.floor(budget);
-			else if (typeof budget === "string" && budget.trim()) {
-				const n = Number(budget);
-				if (Number.isFinite(n) && n > 0) v.tokenBudget = Math.floor(n);
+			if (toolName === "memory_recall") {
+				const format = typeof args.format === "string" ? args.format.trim().toLowerCase() : args.format ?? "full";
+				if (format !== "full" && format !== "compact" && format !== "narrative") throw new Error("format must be one of: full, compact, narrative");
+				v.format = format;
+				if (args.token_budget !== void 0) {
+					const budget = typeof args.token_budget === "string" ? Number(args.token_budget) : args.token_budget;
+					if (typeof budget !== "number" || !Number.isInteger(budget) || budget < 1) throw new Error("token_budget must be a positive integer");
+					v.tokenBudget = budget;
+				}
 			}
 			return v;
 		}
 		case "memory_sessions":
-			v.limit = parseLimit(args["limit"], 20);
+			v.sessionQuery = parseSessionArguments(args);
 			return v;
 		case "memory_governance_delete": {
 			const ids = normalizeList(args["memoryIds"]);
@@ -446,7 +659,22 @@ function validate(toolName, args) {
 			v.reason = args["reason"] || "plugin skill request";
 			return v;
 		}
-		case "memory_export": return v;
+		case "memory_export": {
+			const query = new URLSearchParams();
+			for (const key of [
+				"maxSessions",
+				"offset",
+				"collectionLimit",
+				"collectionOffset"
+			]) {
+				const n = Number(args[key]);
+				const min = key === "maxSessions" || key === "collectionLimit" ? 1 : 0;
+				if (args[key] !== void 0 && Number.isInteger(n) && n >= min) query.set(key, String(n));
+			}
+			if (typeof args["collections"] === "string") query.set("collections", args["collections"]);
+			v.exportQuery = query.toString();
+			return v;
+		}
 		case "memory_audit":
 			v.limit = parseLimit(args["limit"], 50);
 			return v;
@@ -470,7 +698,11 @@ async function handleProxy(v, handle) {
 			const body = {
 				query: v.query,
 				limit: v.limit,
-				format: v.format ?? "full"
+				format: v.format ?? "full",
+				targetLayer: v.targetLayer,
+				project: v.project,
+				cwd: v.cwd,
+				agentId: v.agentId
 			};
 			if (v.tokenBudget != null) body["token_budget"] = v.tokenBudget;
 			return textResponse(await handle.call("/agentmemory/search", {
@@ -481,16 +713,21 @@ async function handleProxy(v, handle) {
 		case "memory_smart_search": {
 			const body = {
 				query: v.query,
-				limit: v.limit
+				limit: v.limit,
+				targetLayer: v.targetLayer,
+				project: v.project,
+				agentId: v.agentId,
+				expandIds: v.expandIds,
+				sessionId: v.sessionId,
+				source: v.source,
+				includeLessons: v.includeLessons
 			};
-			if (v.format != null) body["format"] = v.format;
-			if (v.tokenBudget != null) body["token_budget"] = v.tokenBudget;
 			return textResponse(await handle.call("/agentmemory/smart-search", {
 				method: "POST",
 				body: JSON.stringify(body)
 			}), true);
 		}
-		case "memory_sessions": return textResponse(await handle.call(`/agentmemory/sessions?limit=${v.limit}`, { method: "GET" }), true);
+		case "memory_sessions": return textResponse(await handle.call(`/agentmemory/sessions?${new URLSearchParams(v.sessionQuery)}`, { method: "GET" }), true);
 		case "memory_governance_delete": return textResponse(await handle.call("/agentmemory/governance/memories", {
 			method: "DELETE",
 			body: JSON.stringify({
@@ -499,15 +736,22 @@ async function handleProxy(v, handle) {
 			})
 		}));
 		case "memory_export": try {
-			return textResponse(await handle.call("/agentmemory/export", { method: "GET" }), true);
+			return textResponse(await handle.call(`/agentmemory/export${v.exportQuery ? `?${v.exportQuery}` : ""}`, { method: "GET" }), true);
 		} catch (err) {
-			if (err instanceof ProxyCallError && err.body != null && typeof err.body === "object" && err.body.oversized === true) return textResponse(err.body, true);
+			if (err instanceof ProxyCallError && err.status === 413 && err.body != null && typeof err.body === "object" && err.body.oversized === true) return textResponse(err.body, true);
 			throw err;
 		}
 		case "memory_audit": return textResponse(await handle.call(`/agentmemory/audit?limit=${v.limit}`, { method: "GET" }), true);
 		default: throw new Error(`Unknown tool: ${v.tool}`);
 	}
 }
+function localFallbackNotice(persisted) {
+	const store = persisted ? "the local fallback file, which the server does not read" : "this process's in-memory fallback store, which is lost when the process exits";
+	return {
+		storage: "local",
+		warning: `agentmemory server at ${displayAgentmemoryUrl()} did not confirm this call, so it ran against ${store}.`
+	};
+}
 async function handleLocal(v, kvInstance) {
 	switch (v.tool) {
 		case "memory_save": {
@@ -525,34 +769,98 @@ async function handleLocal(v, kvInstance) {
 				strength: 7,
 				version: 1,
 				isLatest: true,
-				sessionIds: []
+				sessionIds: [],
+				...v.project !== void 0 && { project: v.project },
+				...(v.agentId ?? getAgentId()) !== void 0 && { agentId: v.agentId ?? getAgentId() }
+			});
+			return textResponse({
+				saved: id,
+				...localFallbackNotice(kvInstance.persist())
 			});
-			kvInstance.persist();
-			return textResponse({ saved: id });
 		}
 		case "memory_recall":
 		case "memory_smart_search": {
+			const isolated = isAgentScopeIsolated();
+			const agentId = v.agentId === "*" ? void 0 : v.agentId ?? (isolated ? getAgentId() : void 0);
+			if (isolated && v.agentId !== "*" && !agentId) throw new Error("AGENTMEMORY_AGENT_SCOPE=isolated requires an agentId; pass '*' to read across agents");
 			const query = (v.query || "").toLowerCase();
 			const limit = v.limit ?? DEFAULT_LIMIT;
+			const all = v.targetLayer === "observation" ? [] : await kvInstance.list("mem:memories");
+			const sessions = v.project || v.cwd ? await kvInstance.list("mem:sessions") : [];
+			const sessionsById = new Map(sessions.map((session) => [session.id, session]));
+			const scoped = all.filter((memory) => {
+				if (memory.isLatest === false || agentId && memory.agentId !== agentId) return false;
+				const linkedSessions = (memory.sessionIds ?? []).map((id) => sessionsById.get(id));
+				if (v.project && (memory.project ? memory.project !== v.project : !linkedSessions.some((session) => session?.project === v.project))) return false;
+				if (v.cwd && !linkedSessions.some((session) => session?.cwd === v.cwd)) return false;
+				return true;
+			});
+			if (v.tool === "memory_smart_search" && v.expandIds?.length) {
+				const ids = v.expandIds.map((entry) => typeof entry === "string" ? entry : entry.obsId);
+				const byId = new Map(scoped.map((memory) => [memory.id, memory]));
+				const eligible = ids.filter((id) => byId.has(id));
+				return textResponse({
+					mode: "expanded",
+					results: eligible.slice(0, 20).map((id) => {
+						const observation = memoryToObservation(byId.get(id));
+						return {
+							obsId: id,
+							sessionId: observation.sessionId,
+							observation,
+							layer: "memory"
+						};
+					}),
+					truncated: eligible.length > 20
+				}, true);
+			}
+			const results = scoped.filter((memory) => {
+				const text = [
+					memory.title,
+					memory.content,
+					...memory.files ?? [],
+					...memory.concepts ?? [],
+					...memory.sessionIds ?? [],
+					memory.id
+				].join(" ").toLowerCase();
+				return query.split(/\s+/).every((word) => text.includes(word));
+			}).slice(0, limit);
+			if (v.tool === "memory_recall") return textResponse(buildRecallResponse(results.map((memory) => {
+				const observation = memoryToObservation(memory);
+				return {
+					sessionId: observation.sessionId,
+					observation,
+					score: 1,
+					layer: "memory"
+				};
+			}), v.format ?? "full", v.tokenBudget), true);
 			return textResponse({
 				mode: "compact",
-				results: (await kvInstance.list("mem:memories")).filter((m) => {
-					const text = [
-						typeof m["title"] === "string" ? m["title"] : "",
-						typeof m["content"] === "string" ? m["content"] : "",
-						Array.isArray(m["files"]) ? m["files"].join(" ") : "",
-						Array.isArray(m["concepts"]) ? m["concepts"].join(" ") : "",
-						Array.isArray(m["sessionIds"]) ? m["sessionIds"].join(" ") : "",
-						typeof m["id"] === "string" ? m["id"] : ""
-					].join(" ").toLowerCase();
-					return query.split(/\s+/).every((word) => text.includes(word));
-				}).slice(0, limit)
+				results: results.map((memory) => ({
+					...memory,
+					type: "decision",
+					memoryType: memory.type,
+					obsId: memory.id,
+					sessionId: memory.sessionIds?.[0] ?? "memory",
+					layer: "memory"
+				}))
 			}, true);
 		}
 		case "memory_sessions": {
-			const sessions = await kvInstance.list("mem:sessions");
-			const limit = v.limit ?? 20;
-			return textResponse({ sessions: sessions.slice(0, limit) }, true);
+			const query = v.sessionQuery;
+			const agentId = query.agentId === "*" ? void 0 : query.agentId ?? (isAgentScopeIsolated() ? getAgentId() : void 0);
+			const sessions = (await kvInstance.list("mem:sessions")).filter((session) => session && typeof session.id === "string" && session.id.length > 0).filter((session) => !query.project || session.project === query.project).filter((session) => !agentId || session.agentId === agentId);
+			const key = (session) => session.startedAt || "";
+			const { page, nextCursor } = pageAfterCursor(sortByKeyDesc(sessions, key, (session) => session.id), key, (session) => session.id, query.cursor, Number(query.limit));
+			return textResponse({
+				sessions: await Promise.all(page.map(async (session) => {
+					const summary = await kvInstance.get("mem:summaries", session.id);
+					return summary ? {
+						...session,
+						summary
+					} : session;
+				})),
+				nextCursor
+			}, true);
 		}
 		case "memory_governance_delete": {
 			let deleted = 0;
@@ -560,11 +868,12 @@ async function handleLocal(v, kvInstance) {
 				await kvInstance.delete("mem:memories", id);
 				deleted++;
 			}
-			kvInstance.persist();
+			const persisted = kvInstance.persist();
 			return textResponse({
 				deleted,
 				requested: (v.memoryIds || []).length,
-				reason: v.reason
+				reason: v.reason,
+				...localFallbackNotice(persisted)
 			});
 		}
 		case "memory_export": return textResponse({
@@ -604,6 +913,10 @@ async function handleToolCall(toolName, args, kvInstance = kv) {
 	if (handle.mode === "proxy") try {
 		return await handleProxy(validated, handle);
 	} catch (err) {
+		if (toolName === "memory_sessions" || isAuthenticationError(err) || isProxyRequired()) {
+			invalidateHandle();
+			throw err;
+		}
 		process.stderr.write(`[@agentmemory/mcp] proxy call failed for ${toolName}: ${err instanceof Error ? err.message : String(err)}; invalidating handle and falling back to local KV\n`);
 		invalidateHandle();
 	}
@@ -624,10 +937,12 @@ async function handleToolsList() {
 			if (debug) process.stderr.write(`[@agentmemory/mcp] tools/list: returning ${remote.tools.length} tools from server\n`);
 			return { tools: remote.tools };
 		}
+		if (isProxyRequired()) throw new Error("AgentMemory returned an invalid tool inventory");
 		process.stderr.write(`[@agentmemory/mcp] tools/list: server returned unexpected shape (no .tools array); falling back to local IMPLEMENTED_TOOLS list. Set AGENTMEMORY_DEBUG=1 to inspect response.\n`);
 	} catch (err) {
-		process.stderr.write(`[@agentmemory/mcp] tools/list proxy failed: ${err instanceof Error ? err.message : String(err)}; falling back to local list\n`);
 		invalidateHandle();
+		if (isAuthenticationError(err) || isProxyRequired()) throw err;
+		process.stderr.write(`[@agentmemory/mcp] tools/list proxy failed: ${err instanceof Error ? err.message : String(err)}; falling back to local list\n`);
 	}
 	const fallback = getAllTools().filter((t) => IMPLEMENTED_TOOLS.has(t.name));
 	if (debug) process.stderr.write(`[@agentmemory/mcp] tools/list: returning ${fallback.length} local fallback tools (${fallback.map((t) => t.name).join(",")})\n`);
@@ -666,6 +981,7 @@ const transport = createStdioTransport(async (method, params) => {
 		default: throw new Error(`Unknown method: ${method}`);
 	}
 });
+installCrashHandlers({ persist: () => kv.persist() });
 process.stderr.write(`[@agentmemory/mcp] Standalone MCP server v${SERVER_INFO.version} starting...\n`);
 transport.start();
 process.on("SIGINT", () => {
@@ -679,4 +995,4 @@ process.on("SIGTERM", () => {
 //#endregion
 export {};
 
-//# sourceMappingURL=standalone-DKCdrf1d.mjs.map
+//# sourceMappingURL=standalone-BYo5USDb.mjs.map