@agentmemory/agentmemory 0.9.0 → 0.9.2

package/dist/index.mjs

@@ -4,16 +4,33 @@ import { constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "n
 import { basename, dirname, extname, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import Anthropic from "@anthropic-ai/sdk";
+import { lstat, mkdir, open, readFile, readdir, stat, unlink, utimes, writeFile } from "node:fs/promises";
 import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { z } from "zod";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
-import { lstat, mkdir, open, readFile, readdir, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
 
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
 //#region src/config.ts
 function safeParseInt(value, fallback) {
 	if (!value) return fallback;
@@ -38,37 +55,48 @@ function loadEnvFile() {
 	}
 	return vars;
 }
+function hasRealValue(v) {
+	return typeof v === "string" && v.trim().length > 0;
+}
 function detectProvider(env) {
 	const maxTokens = parseInt(env["MAX_TOKENS"] || "4096", 10);
-	if (env["MINIMAX_API_KEY"]) return {
+	if (hasRealValue(env["MINIMAX_API_KEY"])) return {
 		provider: "minimax",
 		model: env["MINIMAX_MODEL"] || "MiniMax-M2.7",
 		maxTokens
 	};
-	if (env["ANTHROPIC_API_KEY"]) return {
+	if (hasRealValue(env["ANTHROPIC_API_KEY"])) return {
 		provider: "anthropic",
 		model: env["ANTHROPIC_MODEL"] || "claude-sonnet-4-20250514",
 		maxTokens,
 		baseURL: env["ANTHROPIC_BASE_URL"]
 	};
-	if (env["GEMINI_API_KEY"] || env["GOOGLE_API_KEY"]) {
-		if (!env["GEMINI_API_KEY"] && env["GOOGLE_API_KEY"]) process.stderr.write("[agentmemory] GOOGLE_API_KEY detected — treating as GEMINI_API_KEY. Set GEMINI_API_KEY in ~/.agentmemory/.env to silence this warning.\n");
+	if (hasRealValue(env["GEMINI_API_KEY"]) || hasRealValue(env["GOOGLE_API_KEY"])) {
+		if (!hasRealValue(env["GEMINI_API_KEY"]) && hasRealValue(env["GOOGLE_API_KEY"])) process.stderr.write("[agentmemory] GOOGLE_API_KEY detected — treating as GEMINI_API_KEY. Set GEMINI_API_KEY in ~/.agentmemory/.env to silence this warning.\n");
 		return {
 			provider: "gemini",
 			model: env["GEMINI_MODEL"] || "gemini-2.0-flash",
 			maxTokens
 		};
 	}
-	if (env["OPENROUTER_API_KEY"]) return {
+	if (hasRealValue(env["OPENROUTER_API_KEY"])) return {
 		provider: "openrouter",
 		model: env["OPENROUTER_MODEL"] || "anthropic/claude-sonnet-4-20250514",
 		maxTokens
 	};
-	if (env["AGENTMEMORY_AUTO_COMPRESS"] === "true") process.stderr.write("[agentmemory] WARNING: AGENTMEMORY_AUTO_COMPRESS=true but no LLM provider key found (GEMINI_API_KEY, ANTHROPIC_API_KEY, OPENROUTER_API_KEY). Falling back to agent-sdk which shares Claude Code's API quota — this can exhaust a Pro subscription during heavy sessions. Set an API key in ~/.agentmemory/.env to avoid rate limits (#149).\n");
+	if (!(env["AGENTMEMORY_ALLOW_AGENT_SDK"] === "true")) {
+		process.stderr.write("[agentmemory] No LLM provider key found (ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY, MINIMAX_API_KEY). LLM-backed compression and summarization are DISABLED — using no-op provider. This is the safe default: the agent-sdk fallback used to spawn Claude Agent SDK child sessions which inherit Claude Code's plugin hooks and cause infinite Stop-hook recursion (#149 follow-up). To opt in to the agent-sdk fallback anyway, set both AGENTMEMORY_AUTO_COMPRESS=true AND AGENTMEMORY_ALLOW_AGENT_SDK=true — but be aware it will burn your Claude Pro allocation and may still recurse if you use it from inside Claude Code itself.\n");
+		return {
+			provider: "noop",
+			model: "noop",
+			maxTokens
+		};
+	}
+	process.stderr.write("[agentmemory] WARNING: agent-sdk fallback enabled via AGENTMEMORY_ALLOW_AGENT_SDK=true. This spawns @anthropic-ai/claude-agent-sdk child sessions that can trigger the Stop-hook recursion loop (#149 follow-up). A SDK-child env marker is set to block re-entry, but prefer setting a real API key in ~/.agentmemory/.env instead.\n");
 	return {
 		provider: "agent-sdk",
 		model: "claude-sonnet-4-20250514",
-		maxTokens: 4096
+		maxTokens
 	};
 }
 function loadConfig() {
@@ -177,7 +205,16 @@ const VALID_PROVIDERS = new Set([
 	"minimax"
 ]);
 function loadFallbackConfig() {
-	return { providers: (getMergedEnv()["FALLBACK_PROVIDERS"] || "").split(",").map((p) => p.trim()).filter((p) => Boolean(p) && VALID_PROVIDERS.has(p)) };
+	const env = getMergedEnv();
+	const raw = env["FALLBACK_PROVIDERS"] || "";
+	const allowAgentSdk = env["AGENTMEMORY_ALLOW_AGENT_SDK"] === "true";
+	return { providers: raw.split(",").map((p) => p.trim()).filter((p) => Boolean(p) && VALID_PROVIDERS.has(p)).filter((p) => {
+		if (p === "agent-sdk" && !allowAgentSdk) {
+			process.stderr.write("[agentmemory] Ignoring FALLBACK_PROVIDERS entry 'agent-sdk' (AGENTMEMORY_ALLOW_AGENT_SDK is not 'true'). The agent-sdk fallback can spawn Claude Agent SDK child sessions that trigger the Stop-hook recursion loop (#149 follow-up). Opt in explicitly with AGENTMEMORY_ALLOW_AGENT_SDK=true if this is intentional.\n");
+			return false;
+		}
+		return true;
+	}) };
 }
 
 //#endregion
@@ -191,18 +228,26 @@ var AgentSDKProvider = class {
 		return this.query(systemPrompt, userPrompt);
 	}
 	async query(systemPrompt, userPrompt) {
-		const { query } = await import("@anthropic-ai/claude-agent-sdk");
-		const messages = query({
-			prompt: userPrompt,
-			options: {
-				systemPrompt,
-				maxTurns: 1,
-				allowedTools: []
-			}
-		});
-		let result = "";
-		for await (const msg of messages) if (msg.type === "result") result = typeof msg.result === "string" ? msg.result : JSON.stringify(msg.result);
-		return result;
+		if (process.env.AGENTMEMORY_SDK_CHILD === "1") return "";
+		const prev = process.env.AGENTMEMORY_SDK_CHILD;
+		process.env.AGENTMEMORY_SDK_CHILD = "1";
+		try {
+			const { query } = await import("@anthropic-ai/claude-agent-sdk");
+			const messages = query({
+				prompt: userPrompt,
+				options: {
+					systemPrompt,
+					maxTurns: 1,
+					allowedTools: []
+				}
+			});
+			let result = "";
+			for await (const msg of messages) if (msg.type === "result") result = msg.result ?? "";
+			return result;
+		} finally {
+			if (prev === void 0) delete process.env.AGENTMEMORY_SDK_CHILD;
+			else process.env.AGENTMEMORY_SDK_CHILD = prev;
+		}
 	}
 };
 
@@ -227,6 +272,26 @@ var AnthropicProvider = class {
 	async summarize(systemPrompt, userPrompt) {
 		return this.call(systemPrompt, userPrompt);
 	}
+	async describeImage(imageData, mimeType, prompt) {
+		return (await this.client.messages.create({
+			model: this.model,
+			max_tokens: this.maxTokens,
+			messages: [{
+				role: "user",
+				content: [{
+					type: "image",
+					source: {
+						type: "base64",
+						media_type: mimeType,
+						data: imageData
+					}
+				}, {
+					type: "text",
+					text: prompt
+				}]
+			}]
+		})).content.find((b) => b.type === "text")?.text ?? "";
+	}
 	async call(systemPrompt, userPrompt) {
 		return (await this.client.messages.create({
 			model: this.model,
@@ -301,6 +366,25 @@ var MinimaxProvider = class {
 	}
 };
 
+//#endregion
+//#region src/providers/noop.ts
+/**
+* Returns empty strings for every call. Used when no LLM API key is set
+* AND the user has not opted into the agent-sdk fallback via
+* AGENTMEMORY_ALLOW_AGENT_SDK=true. Callers (compress, summarize) must
+* detect the empty result and short-circuit instead of spawning a
+* provider session (#149 / Stop-hook recursion loop fix).
+*/
+var NoopProvider = class {
+	name = "noop";
+	async compress() {
+		return "";
+	}
+	async summarize() {
+		return "";
+	}
+};
+
 //#endregion
 //#region src/providers/openrouter.ts
 var OpenRouterProvider = class {
@@ -512,28 +596,67 @@ var GeminiEmbeddingProvider = class {
 
 //#endregion
 //#region src/providers/embedding/openai.ts
-const API_URL$3 = "https://api.openai.com/v1/embeddings";
+const DEFAULT_BASE_URL = "https://api.openai.com";
+const DEFAULT_MODEL$1 = "text-embedding-3-small";
+/**
+* Known OpenAI embedding model dimensions. Extend as new models ship.
+* Override in any case via OPENAI_EMBEDDING_DIMENSIONS for custom or
+* self-hosted OpenAI-compatible endpoints returning non-standard sizes.
+*/
+const MODEL_DIMENSIONS = {
+	"text-embedding-3-small": 1536,
+	"text-embedding-3-large": 3072,
+	"text-embedding-ada-002": 1536
+};
+const DEFAULT_DIMENSIONS = MODEL_DIMENSIONS[DEFAULT_MODEL$1] ?? 1536;
+function resolveDimensions(model, override) {
+	if (override !== void 0 && override.trim().length > 0) {
+		const parsed = parseInt(override, 10);
+		if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`OPENAI_EMBEDDING_DIMENSIONS must be a positive integer, got: ${override}`);
+		return parsed;
+	}
+	return MODEL_DIMENSIONS[model] ?? DEFAULT_DIMENSIONS;
+}
+/**
+* OpenAI-compatible embedding provider.
+*
+* Required env vars:
+*   OPENAI_API_KEY            — API key
+*
+* Optional:
+*   OPENAI_BASE_URL           — base URL without path (default: https://api.openai.com)
+*   OPENAI_EMBEDDING_MODEL    — model name (default: text-embedding-3-small)
+*   OPENAI_EMBEDDING_DIMENSIONS — override reported dimensions (required for
+*                                 custom / self-hosted models not in the
+*                                 MODEL_DIMENSIONS table above)
+*/
 var OpenAIEmbeddingProvider = class {
 	name = "openai";
-	dimensions = 1536;
+	dimensions;
 	apiKey;
+	baseUrl;
+	model;
 	constructor(apiKey) {
 		this.apiKey = apiKey || getEnvVar("OPENAI_API_KEY") || "";
 		if (!this.apiKey) throw new Error("OPENAI_API_KEY is required");
+		this.baseUrl = getEnvVar("OPENAI_BASE_URL") || DEFAULT_BASE_URL;
+		this.model = getEnvVar("OPENAI_EMBEDDING_MODEL") || DEFAULT_MODEL$1;
+		this.dimensions = resolveDimensions(this.model, getEnvVar("OPENAI_EMBEDDING_DIMENSIONS"));
 	}
 	async embed(text) {
 		const [result] = await this.embedBatch([text]);
 		return result;
 	}
 	async embedBatch(texts) {
-		const response = await fetch(API_URL$3, {
+		const url = `${this.baseUrl}/v1/embeddings`;
+		const response = await fetch(url, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${this.apiKey}`,
 				"Content-Type": "application/json"
 			},
 			body: JSON.stringify({
-				model: "text-embedding-3-small",
+				model: this.model,
 				input: texts
 			})
 		});
@@ -674,7 +797,7 @@ var LocalEmbeddingProvider = class {
 		if (this.extractor) return this.extractor;
 		let transformers;
 		try {
-			transformers = await import("./transformers-BX_tgxdO.mjs");
+			transformers = await import("@xenova/transformers");
 		} catch {
 			throw new Error("Install @xenova/transformers for local embeddings: npm install @xenova/transformers");
 		}
@@ -683,8 +806,86 @@ var LocalEmbeddingProvider = class {
 	}
 };
 
+//#endregion
+//#region src/providers/embedding/clip.ts
+const DEFAULT_MODEL = "Xenova/clip-vit-base-patch32";
+const DIMENSIONS = 512;
+var ClipEmbeddingProvider = class {
+	name = "clip";
+	dimensions = DIMENSIONS;
+	textExtractor = null;
+	imageExtractor = null;
+	transformers = null;
+	modelId;
+	constructor(modelId = DEFAULT_MODEL) {
+		this.modelId = modelId;
+	}
+	async embed(text) {
+		const [vec] = await this.embedBatch([text]);
+		return vec;
+	}
+	async embedBatch(texts) {
+		return (await (await this.getTextExtractor())(texts, {
+			pooling: "mean",
+			normalize: true
+		})).tolist().map((v) => new Float32Array(v));
+	}
+	async embedImage(src) {
+		const image = await loadImage(await this.getTransformers(), src);
+		const output = await (await this.getImageExtractor())(image);
+		return normalize(output.data ?? new Float32Array(output.tolist()[0] || []));
+	}
+	async getTransformers() {
+		if (this.transformers) return this.transformers;
+		try {
+			this.transformers = await import("@xenova/transformers");
+		} catch {
+			throw new Error("Install @xenova/transformers for CLIP image embeddings: npm install @xenova/transformers");
+		}
+		return this.transformers;
+	}
+	async getTextExtractor() {
+		if (this.textExtractor) return this.textExtractor;
+		this.textExtractor = await (await this.getTransformers()).pipeline("feature-extraction", this.modelId);
+		return this.textExtractor;
+	}
+	async getImageExtractor() {
+		if (this.imageExtractor) return this.imageExtractor;
+		this.imageExtractor = await (await this.getTransformers()).pipeline("image-feature-extraction", this.modelId);
+		return this.imageExtractor;
+	}
+};
+async function loadImage(t, src) {
+	if (src.startsWith("data:")) {
+		const comma = src.indexOf(",");
+		const b64 = comma >= 0 ? src.slice(comma + 1) : src;
+		const buf = Buffer.from(b64, "base64");
+		const blob = new Blob([buf]);
+		return t.RawImage.fromBlob(blob);
+	}
+	const data = await readFile(src);
+	const blob = new Blob([data]);
+	return t.RawImage.fromBlob(blob);
+}
+function normalize(vec) {
+	let sum = 0;
+	for (let i = 0; i < vec.length; i++) sum += vec[i] * vec[i];
+	const norm = Math.sqrt(sum);
+	if (norm === 0) return vec;
+	const out = new Float32Array(vec.length);
+	for (let i = 0; i < vec.length; i++) out[i] = vec[i] / norm;
+	return out;
+}
+
 //#endregion
 //#region src/providers/embedding/index.ts
+let imageEmbeddingProvider = null;
+function createImageEmbeddingProvider() {
+	if (process.env["AGENTMEMORY_IMAGE_EMBEDDINGS"] !== "true") return null;
+	if (imageEmbeddingProvider) return imageEmbeddingProvider;
+	imageEmbeddingProvider = new ClipEmbeddingProvider();
+	return imageEmbeddingProvider;
+}
 function createEmbeddingProvider() {
 	const detected = detectEmbeddingProvider();
 	if (!detected) return null;
@@ -736,6 +937,7 @@ function createBaseProvider(config) {
 			return new OpenRouterProvider(geminiKey, config.model, config.maxTokens, "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions");
 		}
 		case "openrouter": return new OpenRouterProvider(requireEnvVar("OPENROUTER_API_KEY"), config.model, config.maxTokens, "https://openrouter.ai/api/v1/chat/completions");
+		case "noop": return new NoopProvider();
 		default: return new AgentSDKProvider();
 	}
 }
@@ -939,7 +1141,12 @@ const KV = {
 	enrichedChunks: (sessionId) => `mem:enriched:${sessionId}`,
 	latentEmbeddings: (obsId) => `mem:latent:${obsId}`,
 	retentionScores: "mem:retention",
-	accessLog: "mem:access"
+	accessLog: "mem:access",
+	imageRefs: "mem:image-refs",
+	imageEmbeddings: "mem:image-embeddings",
+	slots: "mem:slots",
+	globalSlots: "mem:slots:global",
+	state: "mem:state"
 };
 const STREAM = {
 	name: "mem-live",
@@ -1335,7 +1542,7 @@ async function loadPipeline() {
 	if (pipelineLoading) return pipelineLoading;
 	pipelineLoading = (async () => {
 		try {
-			const { pipeline: createPipeline } = await import("./transformers-BX_tgxdO.mjs");
+			const { pipeline: createPipeline } = await import("@xenova/transformers");
 			pipeline = await createPipeline("text-classification", "Xenova/ms-marco-MiniLM-L-6-v2", { quantized: true });
 			return pipeline;
 		} catch {
@@ -2141,7 +2348,7 @@ function buildSyntheticCompression(raw) {
 		inputStr,
 		outputStr
 	].filter((s) => s.length > 0);
-	return {
+	const result = {
 		id: raw.id,
 		sessionId: raw.sessionId,
 		timestamp: raw.timestamp,
@@ -2155,6 +2362,9 @@ function buildSyntheticCompression(raw) {
 		importance: 5,
 		confidence: .3
 	};
+	if (raw.modality) result.modality = raw.modality;
+	if (raw.imageData) result.imageData = raw.imageData;
+	return result;
 }
 
 //#endregion
@@ -2402,6 +2612,24 @@ function registerSearchFunction(sdk, kv) {
 
 //#endregion
 //#region src/functions/observe.ts
+function extractImage(d) {
+	if (!d) return void 0;
+	if (typeof d === "string") {
+		if (d.startsWith("data:image/") || d.startsWith("iVBORw0KGgo") || d.startsWith("/9j/")) return d;
+		return;
+	}
+	if (typeof d === "object" && d !== null) {
+		const obj = d;
+		if (typeof obj["image_data"] === "string") return obj["image_data"];
+		if (typeof obj["image_path"] === "string") return obj["image_path"];
+		if (typeof obj["imageBase64"] === "string") return obj["imageBase64"];
+		if (typeof obj["imagePath"] === "string") return obj["imagePath"];
+		for (const key of Object.keys(obj)) {
+			const match = extractImage(obj[key]);
+			if (match) return match;
+		}
+	}
+}
 function registerObserveFunction(sdk, kv, dedupMap, maxObservationsPerSession) {
 	sdk.registerFunction("mem::observe", async (payload) => {
 		if (!payload?.sessionId || typeof payload.sessionId !== "string" || !payload.hookType || typeof payload.hookType !== "string" || !payload.timestamp || typeof payload.timestamp !== "string") return {
@@ -2433,6 +2661,7 @@ function registerObserveFunction(sdk, kv, dedupMap, maxObservationsPerSession) {
 			hookType: payload.hookType,
 			raw: sanitizedRaw
 		};
+		let extractedImage;
 		if (typeof sanitizedRaw === "object" && sanitizedRaw !== null) {
 			const d = sanitizedRaw;
 			if (payload.hookType === "post_tool_use" || payload.hookType === "post_tool_failure") {
@@ -2441,7 +2670,13 @@ function registerObserveFunction(sdk, kv, dedupMap, maxObservationsPerSession) {
 				raw.toolOutput = d["tool_output"] || d["error"];
 			}
 			if (payload.hookType === "prompt_submit") raw.userPrompt = d["prompt"];
+			extractedImage = extractImage(sanitizedRaw);
+			if (extractedImage) raw.modality = raw.toolInput || raw.toolOutput || raw.userPrompt ? "mixed" : "image";
+		} else if (typeof sanitizedRaw === "string") {
+			extractedImage = extractImage(sanitizedRaw);
+			if (extractedImage) raw.modality = "image";
 		}
+		const pendingImageData = extractedImage;
 		return withKeyedLock(`obs:${payload.sessionId}`, async () => {
 			if (maxObservationsPerSession && maxObservationsPerSession > 0) {
 				if ((await kv.list(KV.observations(payload.sessionId))).length >= maxObservationsPerSession) return {
@@ -2449,7 +2684,29 @@ function registerObserveFunction(sdk, kv, dedupMap, maxObservationsPerSession) {
 					error: `Session observation limit reached (${maxObservationsPerSession})`
 				};
 			}
-			await kv.set(KV.observations(payload.sessionId), obsId, raw);
+			if (pendingImageData && (pendingImageData.startsWith("data:image/") || pendingImageData.startsWith("iVBORw0KGgo") || pendingImageData.startsWith("/9j/"))) {
+				const { saveImageToDisk } = await Promise.resolve().then(() => image_store_exports);
+				const { filePath, bytesWritten } = await saveImageToDisk(pendingImageData);
+				raw.imageData = filePath;
+				const { incrementImageRef } = await Promise.resolve().then(() => image_refs_exports);
+				await incrementImageRef(kv, filePath);
+				sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: bytesWritten });
+				if (process.env["AGENTMEMORY_IMAGE_EMBEDDINGS"] === "true") sdk.triggerVoid("mem::vision-embed", {
+					imageRef: filePath,
+					sessionId: payload.sessionId,
+					observationId: obsId
+				});
+			}
+			try {
+				await kv.set(KV.observations(payload.sessionId), obsId, raw);
+			} catch (error) {
+				if (raw.imageData) {
+					const { deleteImage } = await Promise.resolve().then(() => image_store_exports);
+					const { deletedBytes } = await deleteImage(raw.imageData);
+					if (deletedBytes > 0) sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: -deletedBytes });
+				}
+				throw error;
+			}
 			if (dedupMap && dedupHash) dedupMap.record(dedupHash);
 			await sdk.trigger({
 				function_id: "stream::set",
@@ -2479,15 +2736,26 @@ function registerObserveFunction(sdk, kv, dedupMap, maxObservationsPerSession) {
 				action: TriggerAction.Void()
 			});
 			const session = await kv.get(KV.sessions, payload.sessionId);
-			if (session) await kv.update(KV.sessions, payload.sessionId, [{
-				type: "set",
-				path: "updatedAt",
-				value: (/* @__PURE__ */ new Date()).toISOString()
-			}, {
-				type: "set",
-				path: "observationCount",
-				value: (session.observationCount || 0) + 1
-			}]);
+			if (session) {
+				const updates = [{
+					type: "set",
+					path: "updatedAt",
+					value: (/* @__PURE__ */ new Date()).toISOString()
+				}, {
+					type: "set",
+					path: "observationCount",
+					value: (session.observationCount || 0) + 1
+				}];
+				if (!session.firstPrompt && typeof raw.userPrompt === "string") {
+					const trimmed = raw.userPrompt.replace(/\s+/g, " ").trim();
+					if (trimmed.length > 0) updates.push({
+						type: "set",
+						path: "firstPrompt",
+						value: trimmed.slice(0, 200)
+					});
+				}
+				await kv.update(KV.sessions, payload.sessionId, updates);
+			}
 			if (isAutoCompressEnabled()) await sdk.trigger({
 				function_id: "mem::compress",
 				payload: {
@@ -2538,6 +2806,815 @@ function registerObserveFunction(sdk, kv, dedupMap, maxObservationsPerSession) {
 	});
 }
 
+//#endregion
+//#region src/utils/image-store.ts
+var image_store_exports = /* @__PURE__ */ __exportAll({
+	IMAGES_DIR: () => IMAGES_DIR,
+	deleteImage: () => deleteImage,
+	getMaxBytes: () => getMaxBytes,
+	isManagedImagePath: () => isManagedImagePath,
+	saveImageToDisk: () => saveImageToDisk,
+	touchImage: () => touchImage
+});
+const IMAGES_DIR = join(homedir(), ".agentmemory", "images");
+const DEFAULT_MAX_BYTES = 500 * 1024 * 1024;
+function getMaxBytes() {
+	return Number(process.env.AGENTMEMORY_IMAGE_STORE_MAX_BYTES) || DEFAULT_MAX_BYTES;
+}
+function isManagedImagePath(filePath) {
+	const resolved = resolve(filePath);
+	const normalizedImagesDir = resolve(IMAGES_DIR);
+	return resolved.startsWith(normalizedImagesDir + sep) || resolved === normalizedImagesDir;
+}
+function contentHash(data) {
+	return createHash("sha256").update(data).digest("hex");
+}
+async function saveImageToDisk(base64Data) {
+	if (!base64Data) return {
+		filePath: "",
+		bytesWritten: 0
+	};
+	if (!existsSync(IMAGES_DIR)) await mkdir(IMAGES_DIR, { recursive: true });
+	let cleanBase64 = base64Data;
+	let ext = "png";
+	if (base64Data.startsWith("data:image/")) {
+		const commaIdx = base64Data.indexOf(",");
+		if (commaIdx !== -1) {
+			const meta = base64Data.substring(0, commaIdx);
+			if (meta.includes("jpeg") || meta.includes("jpg")) ext = "jpg";
+			else if (meta.includes("webp")) ext = "webp";
+			else if (meta.includes("gif")) ext = "gif";
+			cleanBase64 = base64Data.substring(commaIdx + 1);
+		}
+	} else if (base64Data.startsWith("/9j/")) ext = "jpg";
+	const filePath = join(IMAGES_DIR, `${contentHash(cleanBase64)}.${ext}`);
+	if (existsSync(filePath)) return {
+		filePath,
+		bytesWritten: 0
+	};
+	await writeFile(filePath, Buffer.from(cleanBase64, "base64"));
+	return {
+		filePath,
+		bytesWritten: (await stat(filePath)).size
+	};
+}
+async function deleteImage(filePath) {
+	if (!filePath) return { deletedBytes: 0 };
+	if (!isManagedImagePath(filePath)) return { deletedBytes: 0 };
+	try {
+		if (existsSync(filePath)) {
+			const size = (await stat(filePath)).size;
+			await unlink(filePath);
+			return { deletedBytes: size };
+		}
+	} catch (err) {
+		console.error("[agentmemory] Failed to delete image context:", err);
+	}
+	return { deletedBytes: 0 };
+}
+/** Touch an image file to update its mtime (marking it as recently used for LRU eviction) */
+async function touchImage(filePath) {
+	if (!filePath || !isManagedImagePath(filePath)) return;
+	try {
+		if (existsSync(filePath)) {
+			const now = /* @__PURE__ */ new Date();
+			await utimes(filePath, now, now);
+		}
+	} catch (err) {}
+}
+
+//#endregion
+//#region src/functions/image-refs.ts
+var image_refs_exports = /* @__PURE__ */ __exportAll({
+	decrementImageRef: () => decrementImageRef,
+	getImageRefCount: () => getImageRefCount,
+	incrementImageRef: () => incrementImageRef
+});
+async function getImageRefCount(kv, filePath) {
+	const count = await kv.get(KV.imageRefs, filePath);
+	return count ? Number(count) : 0;
+}
+async function incrementImageRef(kv, filePath) {
+	return withKeyedLock(`imgRef:${filePath}`, async () => {
+		const current = await getImageRefCount(kv, filePath);
+		await kv.set(KV.imageRefs, filePath, current + 1);
+		await touchImage(filePath);
+	});
+}
+async function decrementImageRef(kv, sdk, filePath) {
+	return withKeyedLock(`imgRef:${filePath}`, async () => {
+		const current = await getImageRefCount(kv, filePath);
+		if (current <= 1) {
+			await kv.delete(KV.imageEmbeddings, filePath);
+			await kv.delete(KV.imageRefs, filePath);
+			const { deletedBytes } = await deleteImage(filePath);
+			if (deletedBytes > 0) sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: -deletedBytes });
+		} else await kv.set(KV.imageRefs, filePath, current - 1);
+	});
+}
+
+//#endregion
+//#region src/functions/image-quota-cleanup.ts
+const GRACE_PERIOD_MS = 3e4;
+function registerImageQuotaCleanup(sdk, kv) {
+	sdk.registerFunction("mem::image-quota-cleanup", async () => {
+		const now = Date.now();
+		return withKeyedLock("system:cleanupLock", async () => {
+			let totalSize = 0;
+			const fileStats = [];
+			try {
+				const files = await readdir(IMAGES_DIR);
+				for (const file of files) {
+					if (file.startsWith(".")) continue;
+					const filePath = join(IMAGES_DIR, file);
+					const s = await stat(filePath);
+					if (s.isFile()) {
+						fileStats.push({
+							filePath,
+							size: s.size,
+							mtimeMs: s.mtimeMs
+						});
+						totalSize += s.size;
+					}
+				}
+			} catch {
+				return {
+					success: true,
+					evicted: 0,
+					freedBytes: 0
+				};
+			}
+			const limit = getMaxBytes();
+			if (totalSize <= limit) return {
+				success: true,
+				evicted: 0,
+				freedBytes: 0,
+				underQuota: true
+			};
+			fileStats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+			let totalToFree = totalSize - limit;
+			let evicted = 0;
+			let freedBytes = 0;
+			for (const f of fileStats) {
+				if (totalToFree <= 0) break;
+				if (now - f.mtimeMs < GRACE_PERIOD_MS) continue;
+				await withKeyedLock(`imgRef:${f.filePath}`, async () => {
+					let refCount;
+					try {
+						refCount = await getImageRefCount(kv, f.filePath);
+					} catch (err) {
+						logger.error("Failed to read refCount; skipping eviction", {
+							filePath: f.filePath,
+							error: err instanceof Error ? err.message : String(err)
+						});
+						return;
+					}
+					if (refCount > 0) return;
+					const { deletedBytes } = await deleteImage(f.filePath);
+					if (deletedBytes > 0) {
+						sdk.triggerVoid("mem::disk-size-delta", { deltaBytes: -deletedBytes });
+						totalToFree -= deletedBytes;
+						freedBytes += deletedBytes;
+						evicted++;
+					}
+				});
+			}
+			if (evicted > 0) {
+				const freedMb = (freedBytes / (1024 * 1024)).toFixed(1);
+				logger.info("Image quota cleanup complete", {
+					evicted,
+					freedMb
+				});
+			}
+			return {
+				success: true,
+				evicted,
+				freedBytes
+			};
+		});
+	});
+}
+
+//#endregion
+//#region src/functions/audit.ts
+async function recordAudit(kv, operation, functionId, targetIds, details = {}, qualityScore, userId) {
+	const entry = {
+		id: generateId("aud"),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		operation,
+		userId,
+		functionId,
+		targetIds,
+		details,
+		qualityScore
+	};
+	await kv.set(KV.audit, entry.id, entry);
+	return entry;
+}
+async function safeAudit(kv, operation, functionId, targetIds, details = {}, qualityScore, userId) {
+	try {
+		await recordAudit(kv, operation, functionId, targetIds, details, qualityScore, userId);
+	} catch (err) {
+		try {
+			logger.warn("audit write failed", {
+				functionId,
+				operation,
+				targetIds,
+				error: err instanceof Error ? err.message : String(err)
+			});
+		} catch {}
+	}
+}
+async function queryAudit(kv, filter) {
+	let entries = [...await kv.list(KV.audit)].sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+	if (filter?.operation) entries = entries.filter((e) => e.operation === filter.operation);
+	if (filter?.dateFrom) {
+		const from = new Date(filter.dateFrom).getTime();
+		if (Number.isNaN(from)) throw new Error(`Invalid dateFrom: ${filter.dateFrom}`);
+		entries = entries.filter((e) => new Date(e.timestamp).getTime() >= from);
+	}
+	if (filter?.dateTo) {
+		const to = new Date(filter.dateTo).getTime();
+		if (Number.isNaN(to)) throw new Error(`Invalid dateTo: ${filter.dateTo}`);
+		entries = entries.filter((e) => new Date(e.timestamp).getTime() <= to);
+	}
+	return entries.slice(0, filter?.limit || 100);
+}
+
+//#endregion
+//#region src/functions/vision-search.ts
+function registerVisionSearchFunctions(sdk, kv, imageProvider) {
+	sdk.registerFunction("mem::vision-embed", async (data) => {
+		if (!imageProvider?.embedImage) return {
+			success: false,
+			error: "image embeddings disabled (set AGENTMEMORY_IMAGE_EMBEDDINGS=true)"
+		};
+		if (!data?.imageRef || typeof data.imageRef !== "string") return {
+			success: false,
+			error: "imageRef required"
+		};
+		if (!isManagedImagePath(data.imageRef)) return {
+			success: false,
+			error: "imageRef must point to a file under the managed image store"
+		};
+		const refCount = await kv.get(KV.imageRefs, data.imageRef);
+		if (!refCount || Number(refCount) < 1) return {
+			success: false,
+			error: "imageRef not registered in mem:image-refs"
+		};
+		try {
+			const vec = await imageProvider.embedImage(data.imageRef);
+			const stored = {
+				imageRef: data.imageRef,
+				vector: Array.from(vec),
+				modelName: imageProvider.name,
+				dimensions: imageProvider.dimensions,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				sessionId: data.sessionId,
+				observationId: data.observationId
+			};
+			await kv.set(KV.imageEmbeddings, data.imageRef, stored);
+			await recordAudit(kv, "vision_embed", "mem::vision-embed", [data.imageRef], {
+				modelName: imageProvider.name,
+				dimensions: stored.dimensions,
+				sessionId: data.sessionId,
+				observationId: data.observationId
+			});
+			return {
+				success: true,
+				imageRef: data.imageRef,
+				dimensions: stored.dimensions
+			};
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			logger.warn("vision-embed failed", {
+				imageRef: data.imageRef,
+				error: msg
+			});
+			return {
+				success: false,
+				error: msg
+			};
+		}
+	});
+	sdk.registerFunction("mem::vision-search", async (data) => {
+		if (!imageProvider?.embedImage) return {
+			success: false,
+			error: "image embeddings disabled (set AGENTMEMORY_IMAGE_EMBEDDINGS=true)"
+		};
+		const requestedTopK = typeof data?.topK === "number" && Number.isFinite(data.topK) ? Math.trunc(data.topK) : 10;
+		const topK = Math.min(50, Math.max(1, requestedTopK));
+		let queryVec = null;
+		try {
+			if (data?.queryText) queryVec = await imageProvider.embed(data.queryText);
+			else if (data?.queryImageBase64) {
+				const b64 = data.queryImageBase64.startsWith("data:") ? data.queryImageBase64 : `data:image/png;base64,${data.queryImageBase64}`;
+				queryVec = await imageProvider.embedImage(b64);
+			} else if (data?.queryImageRef) {
+				if (!isManagedImagePath(data.queryImageRef)) return {
+					success: false,
+					error: "queryImageRef must point to a file under the managed image store"
+				};
+				const refCount = await kv.get(KV.imageRefs, data.queryImageRef);
+				if (!refCount || Number(refCount) < 1) return {
+					success: false,
+					error: "queryImageRef not registered in mem:image-refs"
+				};
+				queryVec = await imageProvider.embedImage(data.queryImageRef);
+			} else return {
+				success: false,
+				error: "queryText, queryImageRef, or queryImageBase64 required"
+			};
+		} catch (err) {
+			return {
+				success: false,
+				error: `query embed failed: ${err instanceof Error ? err.message : String(err)}`
+			};
+		}
+		if (!queryVec) return {
+			success: false,
+			error: "failed to build query vector"
+		};
+		const stored = await kv.list(KV.imageEmbeddings);
+		const scored = (data?.sessionId ? stored.filter((s) => s.sessionId === data.sessionId) : stored).map((s) => ({
+			imageRef: s.imageRef,
+			score: cosine(queryVec, s.vector),
+			sessionId: s.sessionId,
+			observationId: s.observationId,
+			updatedAt: s.updatedAt
+		}));
+		scored.sort((a, b) => b.score - a.score);
+		return {
+			success: true,
+			results: scored.slice(0, topK),
+			total: scored.length
+		};
+	});
+}
+function cosine(a, b) {
+	if (a.length !== b.length) return 0;
+	let dot = 0;
+	let normA = 0;
+	let normB = 0;
+	for (let i = 0; i < a.length; i++) {
+		dot += a[i] * b[i];
+		normA += a[i] * a[i];
+		normB += b[i] * b[i];
+	}
+	const denom = Math.sqrt(normA) * Math.sqrt(normB);
+	return denom === 0 ? 0 : dot / denom;
+}
+
+//#endregion
+//#region src/functions/slots.ts
+const DEFAULT_SIZE_LIMIT = 2e3;
+const DEFAULT_SLOTS = [
+	{
+		label: "persona",
+		content: "",
+		sizeLimit: 1e3,
+		description: "How the agent should see itself: role, tone, behavioural guidelines.",
+		pinned: true,
+		readOnly: false,
+		scope: "global"
+	},
+	{
+		label: "user_preferences",
+		content: "",
+		sizeLimit: 2e3,
+		description: "Coding style, tool preferences, naming conventions, and other habits the user wants preserved across sessions.",
+		pinned: true,
+		readOnly: false,
+		scope: "global"
+	},
+	{
+		label: "tool_guidelines",
+		content: "",
+		sizeLimit: 1500,
+		description: "Rules the agent should follow when picking or sequencing tools (e.g. prefer X over Y, never run Z without confirmation).",
+		pinned: true,
+		readOnly: false,
+		scope: "global"
+	},
+	{
+		label: "project_context",
+		content: "",
+		sizeLimit: 3e3,
+		description: "Architecture decisions, codebase conventions, build/test commands, and cross-cutting constraints for the current project.",
+		pinned: true,
+		readOnly: false,
+		scope: "project"
+	},
+	{
+		label: "guidance",
+		content: "",
+		sizeLimit: 1500,
+		description: "Active advice for the next session: what to focus on, what to avoid, open risks.",
+		pinned: true,
+		readOnly: false,
+		scope: "project"
+	},
+	{
+		label: "pending_items",
+		content: "",
+		sizeLimit: 2e3,
+		description: "Unfinished work, explicit TODOs, and promises made but not yet delivered.",
+		pinned: true,
+		readOnly: false,
+		scope: "project"
+	},
+	{
+		label: "session_patterns",
+		content: "",
+		sizeLimit: 1500,
+		description: "Recurring behaviours and common struggles observed across recent sessions.",
+		pinned: false,
+		readOnly: false,
+		scope: "project"
+	},
+	{
+		label: "self_notes",
+		content: "",
+		sizeLimit: 1500,
+		description: "Free-form notes the agent keeps for itself: hypotheses, dead ends, things to revisit.",
+		pinned: false,
+		readOnly: false,
+		scope: "project"
+	}
+];
+function isSlotsEnabled() {
+	return process.env["AGENTMEMORY_SLOTS"] === "true";
+}
+function isReflectEnabled() {
+	return process.env["AGENTMEMORY_REFLECT"] === "true";
+}
+function scopeKv(scope) {
+	return scope === "global" ? KV.globalSlots : KV.slots;
+}
+function nowIso() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function validateLabel(label) {
+	if (typeof label !== "string") return null;
+	const trimmed = label.trim();
+	if (!trimmed || trimmed.length > 64) return null;
+	if (!/^[a-z][a-z0-9_]*$/.test(trimmed)) return null;
+	return trimmed;
+}
+async function readSlot(kv, label) {
+	const project = await kv.get(KV.slots, label);
+	if (project) return {
+		slot: project,
+		scope: "project"
+	};
+	const global = await kv.get(KV.globalSlots, label);
+	if (global) return {
+		slot: global,
+		scope: "global"
+	};
+	return {
+		slot: null,
+		scope: "project"
+	};
+}
+async function readSlotInScope(kv, label, scope) {
+	return kv.get(scopeKv(scope), label);
+}
+function validateScope(raw) {
+	if (raw === void 0 || raw === null) return "project";
+	if (raw === "project" || raw === "global") return raw;
+	return null;
+}
+function validateSizeLimit(raw) {
+	if (raw === void 0 || raw === null) return DEFAULT_SIZE_LIMIT;
+	if (typeof raw !== "number") return null;
+	if (!Number.isInteger(raw) || raw < 1 || raw > 2e4) return null;
+	return raw;
+}
+async function seedDefaults(kv) {
+	const ts = nowIso();
+	for (const tmpl of DEFAULT_SLOTS) {
+		const target = scopeKv(tmpl.scope);
+		if (await kv.get(target, tmpl.label)) continue;
+		const slot = {
+			...tmpl,
+			createdAt: ts,
+			updatedAt: ts
+		};
+		await kv.set(target, tmpl.label, slot);
+	}
+}
+function registerSlotsFunctions(sdk, kv) {
+	seedDefaults(kv).catch((err) => {
+		logger.warn("slot defaults seed failed", { error: err instanceof Error ? err.message : String(err) });
+	});
+	sdk.registerFunction("mem::slot-list", async () => {
+		const [project, global] = await Promise.all([kv.list(KV.slots), kv.list(KV.globalSlots)]);
+		const merged = /* @__PURE__ */ new Map();
+		for (const s of global) merged.set(s.label, s);
+		for (const s of project) merged.set(s.label, s);
+		return {
+			success: true,
+			slots: Array.from(merged.values()).sort((a, b) => a.label.localeCompare(b.label))
+		};
+	});
+	sdk.registerFunction("mem::slot-get", async (data) => {
+		const label = validateLabel(data?.label);
+		if (!label) return {
+			success: false,
+			error: "label required (lowercase, starts with letter, [a-z0-9_])"
+		};
+		const { slot, scope } = await readSlot(kv, label);
+		if (!slot) return {
+			success: false,
+			error: "slot not found"
+		};
+		return {
+			success: true,
+			slot,
+			scope
+		};
+	});
+	sdk.registerFunction("mem::slot-create", async (data) => {
+		const label = validateLabel(data?.label);
+		if (!label) return {
+			success: false,
+			error: "label required (lowercase, starts with letter, [a-z0-9_])"
+		};
+		const scope = validateScope(data?.scope);
+		if (!scope) return {
+			success: false,
+			error: "scope must be 'project' or 'global'"
+		};
+		const sizeLimit = validateSizeLimit(data?.sizeLimit);
+		if (sizeLimit === null) return {
+			success: false,
+			error: "sizeLimit must be an integer between 1 and 20000"
+		};
+		const content = typeof data?.content === "string" ? data.content : "";
+		if (content.length > sizeLimit) return {
+			success: false,
+			error: `content exceeds sizeLimit (${content.length} > ${sizeLimit})`
+		};
+		const description = typeof data?.description === "string" ? data.description : "";
+		const pinned = typeof data?.pinned === "boolean" ? data.pinned : true;
+		return withKeyedLock(`slot:${label}`, async () => {
+			if (await readSlotInScope(kv, label, scope)) return {
+				success: false,
+				error: `slot already exists in ${scope} scope`
+			};
+			const ts = nowIso();
+			const slot = {
+				label,
+				content,
+				sizeLimit,
+				description,
+				pinned,
+				readOnly: false,
+				scope,
+				createdAt: ts,
+				updatedAt: ts
+			};
+			await kv.set(scopeKv(scope), label, slot);
+			await recordAudit(kv, "slot_create", "mem::slot-create", [label], {
+				scope,
+				sizeLimit: slot.sizeLimit,
+				pinned: slot.pinned
+			});
+			return {
+				success: true,
+				slot
+			};
+		});
+	});
+	sdk.registerFunction("mem::slot-append", async (data) => {
+		const label = validateLabel(data?.label);
+		if (!label) return {
+			success: false,
+			error: "label required"
+		};
+		const text = typeof data?.text === "string" ? data.text : "";
+		if (!text) return {
+			success: false,
+			error: "text required"
+		};
+		return withKeyedLock(`slot:${label}`, async () => {
+			const { slot, scope } = await readSlot(kv, label);
+			if (!slot) return {
+				success: false,
+				error: "slot not found (use mem::slot-create first)"
+			};
+			if (slot.readOnly) return {
+				success: false,
+				error: "slot is read-only"
+			};
+			const sep = slot.content && !slot.content.endsWith("\n") ? "\n" : "";
+			const next = `${slot.content}${sep}${text}`;
+			if (next.length > slot.sizeLimit) return {
+				success: false,
+				error: `append would exceed sizeLimit (${next.length} > ${slot.sizeLimit}). Use mem::slot-replace to compact first.`,
+				currentSize: slot.content.length,
+				sizeLimit: slot.sizeLimit
+			};
+			const updated = {
+				...slot,
+				content: next,
+				updatedAt: nowIso()
+			};
+			await kv.set(scopeKv(scope), label, updated);
+			await recordAudit(kv, "slot_append", "mem::slot-append", [label], {
+				scope,
+				added: text.length,
+				total: next.length
+			});
+			return {
+				success: true,
+				slot: updated,
+				size: next.length
+			};
+		});
+	});
+	sdk.registerFunction("mem::slot-replace", async (data) => {
+		const label = validateLabel(data?.label);
+		if (!label) return {
+			success: false,
+			error: "label required"
+		};
+		if (typeof data?.content !== "string") return {
+			success: false,
+			error: "content required (string)"
+		};
+		return withKeyedLock(`slot:${label}`, async () => {
+			const { slot, scope } = await readSlot(kv, label);
+			if (!slot) return {
+				success: false,
+				error: "slot not found (use mem::slot-create first)"
+			};
+			if (slot.readOnly) return {
+				success: false,
+				error: "slot is read-only"
+			};
+			if (data.content.length > slot.sizeLimit) return {
+				success: false,
+				error: `content exceeds sizeLimit (${data.content.length} > ${slot.sizeLimit})`,
+				sizeLimit: slot.sizeLimit
+			};
+			const updated = {
+				...slot,
+				content: data.content,
+				updatedAt: nowIso()
+			};
+			await kv.set(scopeKv(scope), label, updated);
+			await recordAudit(kv, "slot_replace", "mem::slot-replace", [label], {
+				scope,
+				before: slot.content.length,
+				after: data.content.length
+			});
+			return {
+				success: true,
+				slot: updated,
+				size: data.content.length
+			};
+		});
+	});
+	sdk.registerFunction("mem::slot-delete", async (data) => {
+		const label = validateLabel(data?.label);
+		if (!label) return {
+			success: false,
+			error: "label required"
+		};
+		return withKeyedLock(`slot:${label}`, async () => {
+			const { slot, scope } = await readSlot(kv, label);
+			if (!slot) return {
+				success: false,
+				error: "slot not found"
+			};
+			if (slot.readOnly) return {
+				success: false,
+				error: "slot is read-only"
+			};
+			await kv.delete(scopeKv(scope), label);
+			await recordAudit(kv, "slot_delete", "mem::slot-delete", [label], {
+				scope,
+				size: slot.content.length
+			});
+			return { success: true };
+		});
+	});
+	sdk.registerFunction("mem::slot-reflect", async (data) => {
+		if (!data?.sessionId || typeof data.sessionId !== "string") return {
+			success: false,
+			error: "sessionId required"
+		};
+		const max = typeof data.maxObservations === "number" && Number.isInteger(data.maxObservations) && data.maxObservations > 0 ? Math.min(200, data.maxObservations) : 50;
+		const observations = await kv.list(KV.observations(data.sessionId));
+		if (observations.length === 0) return {
+			success: true,
+			applied: 0,
+			reason: "no observations for session"
+		};
+		const recent = observations.slice().sort((a, b) => (b.timestamp || "").localeCompare(a.timestamp || "")).slice(0, max);
+		const pendingLines = [];
+		const patternCounts = /* @__PURE__ */ new Map();
+		const files = /* @__PURE__ */ new Set();
+		for (const obs of recent) {
+			const title = (obs.title || "").toLowerCase();
+			if ((obs.narrative || "").toLowerCase().includes("todo") || title.includes("todo")) pendingLines.push(`- ${obs.title || obs.id}`);
+			if (obs.type === "error") patternCounts.set("errors", (patternCounts.get("errors") ?? 0) + 1);
+			if (obs.type === "command_run") patternCounts.set("commands", (patternCounts.get("commands") ?? 0) + 1);
+			if (obs.files) for (const f of obs.files) files.add(f);
+		}
+		let applied = 0;
+		if (pendingLines.length > 0) {
+			if (await withKeyedLock(`slot:pending_items`, async () => {
+				const { slot, scope } = await readSlot(kv, "pending_items");
+				if (!slot) return false;
+				const already = new Set(slot.content.split("\n"));
+				const fresh = pendingLines.filter((line) => !already.has(line));
+				if (fresh.length === 0) return false;
+				const sep = slot.content && !slot.content.endsWith("\n") ? "\n" : "";
+				const next = `${slot.content}${sep}${fresh.join("\n")}`;
+				const truncated = next.length > slot.sizeLimit ? next.slice(next.length - slot.sizeLimit) : next;
+				await kv.set(scopeKv(scope), "pending_items", {
+					...slot,
+					content: truncated,
+					updatedAt: nowIso()
+				});
+				return true;
+			})) applied++;
+		}
+		if (patternCounts.size > 0) {
+			if (await withKeyedLock(`slot:session_patterns`, async () => {
+				const { slot, scope } = await readSlot(kv, "session_patterns");
+				if (!slot) return false;
+				const summary = [`last reflection: ${nowIso()}`, ...Array.from(patternCounts.entries()).map(([kind, count]) => `- ${kind}: ${count} in last ${recent.length} observations`)].join("\n");
+				const next = summary.length > slot.sizeLimit ? summary.slice(0, slot.sizeLimit) : summary;
+				await kv.set(scopeKv(scope), "session_patterns", {
+					...slot,
+					content: next,
+					updatedAt: nowIso()
+				});
+				return true;
+			})) applied++;
+		}
+		if (files.size > 0) {
+			if (await withKeyedLock(`slot:project_context`, async () => {
+				const { slot, scope } = await readSlot(kv, "project_context");
+				if (!slot) return false;
+				const already = slot.content;
+				const fresh = Array.from(files).filter((f) => !already.includes(f)).slice(0, 20);
+				if (fresh.length === 0) return false;
+				const header = already.length === 0 ? "Files touched in recent sessions:" : "";
+				const nextRaw = `${already}${already && !already.endsWith("\n") ? "\n" : ""}${header ? header + "\n" : ""}${fresh.map((f) => `- ${f}`).join("\n")}`;
+				const next = nextRaw.length > slot.sizeLimit ? nextRaw.slice(nextRaw.length - slot.sizeLimit) : nextRaw;
+				await kv.set(scopeKv(scope), "project_context", {
+					...slot,
+					content: next,
+					updatedAt: nowIso()
+				});
+				return true;
+			})) applied++;
+		}
+		if (applied > 0) await recordAudit(kv, "slot_reflect", "mem::slot-reflect", [data.sessionId], {
+			observationCount: recent.length,
+			slotsUpdated: applied
+		});
+		return {
+			success: true,
+			applied,
+			observationsReviewed: recent.length
+		};
+	});
+}
+
+//#endregion
+//#region src/functions/disk-size-manager.ts
+const DISK_SIZE_KEY = "system:currentDiskSize";
+function registerDiskSizeManager(sdk, kv) {
+	sdk.registerFunction("mem::disk-size-delta", async (data) => {
+		if (typeof data?.deltaBytes !== "number" || !isFinite(data.deltaBytes)) return {
+			success: false,
+			error: "deltaBytes must be a finite number"
+		};
+		return withKeyedLock(DISK_SIZE_KEY, async () => {
+			let newTotal = (await kv.get(KV.state, DISK_SIZE_KEY) || 0) + data.deltaBytes;
+			if (newTotal < 0) newTotal = 0;
+			await kv.set(KV.state, DISK_SIZE_KEY, newTotal);
+			if (data.deltaBytes > 0 && newTotal > getMaxBytes()) {
+				sdk.triggerVoid("mem::image-quota-cleanup", {});
+				logger.info("Disk quota exceeded, cleanup triggered", {
+					currentBytes: newTotal,
+					maxBytes: getMaxBytes()
+				});
+			}
+			return {
+				success: true,
+				currentTotal: newTotal
+			};
+		});
+	});
+}
+
 //#endregion
 //#region src/prompts/compression.ts
 const COMPRESSION_SYSTEM = `You are a memory compression engine for an AI coding agent. Your job is to extract the essential information from a tool usage observation and compress it into structured data.
@@ -2586,6 +3663,17 @@ function truncate$1(s, max) {
 	return s.length > max ? s.slice(0, max) + "\n[...truncated]" : s;
 }
 
+//#endregion
+//#region src/prompts/vision.ts
+const VISION_DESCRIPTION_PROMPT = `Describe what this image shows in the context of software development. Extract:
+- What type of image this is (screenshot, diagram, mockup, terminal output, error, etc.)
+- Key entities visible (files, components, UI elements, error messages)
+- Relationships or flow shown
+- Any decisions, errors, or state visible
+- Text content visible in the image
+
+Be concise but preserve all technically relevant details. Output plain text, no XML.`;
+
 //#endregion
 //#region src/prompts/xml.ts
 const VALID_TAG = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
@@ -2819,6 +3907,7 @@ const VALID_TYPES$1 = new Set([
 	"subagent",
 	"notification",
 	"task",
+	"image",
 	"other"
 ]);
 function parseCompressionXml(xml) {
@@ -2839,11 +3928,32 @@ function parseCompressionXml(xml) {
 function registerCompressFunction(sdk, kv, provider, metricsStore) {
 	sdk.registerFunction("mem::compress", async (data) => {
 		const startMs = Date.now();
+		let imageDescription;
+		const hasImage = data.raw.modality === "image" || data.raw.modality === "mixed";
+		if (hasImage && data.raw.imageData && provider.describeImage) try {
+			let base64Data = data.raw.imageData;
+			let mimeType = "image/png";
+			if (!data.raw.imageData.startsWith("/9j/") && !data.raw.imageData.startsWith("iVBOR")) {
+				if (!isManagedImagePath(data.raw.imageData)) throw new Error(`Refusing to read image outside managed store: ${data.raw.imageData}`);
+				base64Data = readFileSync(data.raw.imageData).toString("base64");
+				if (data.raw.imageData.endsWith(".jpg") || data.raw.imageData.endsWith(".jpeg")) mimeType = "image/jpeg";
+				else if (data.raw.imageData.endsWith(".webp")) mimeType = "image/webp";
+				else if (data.raw.imageData.endsWith(".gif")) mimeType = "image/gif";
+			}
+			imageDescription = await provider.describeImage(base64Data, mimeType, VISION_DESCRIPTION_PROMPT);
+			logger.info("Image described by vision model", { obsId: data.observationId });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			logger.warn("Vision model call failed, falling back to text-only compression", {
+				obsId: data.observationId,
+				error: msg
+			});
+		}
 		const prompt = buildCompressionPrompt({
 			hookType: data.raw.hookType,
 			toolName: data.raw.toolName,
 			toolInput: data.raw.toolInput,
-			toolOutput: data.raw.toolOutput,
+			toolOutput: imageDescription ? `[Image Description]: ${imageDescription}\n\n${data.raw.toolOutput ?? ""}` : data.raw.toolOutput,
 			userPrompt: data.raw.userPrompt,
 			timestamp: data.raw.timestamp
 		});
@@ -2880,7 +3990,10 @@ function registerCompressFunction(sdk, kv, provider, metricsStore) {
 				sessionId: data.sessionId,
 				timestamp: data.raw.timestamp,
 				...parsed,
-				confidence: qualityScore / 100
+				confidence: qualityScore / 100,
+				...hasImage ? { modality: data.raw.modality } : {},
+				...imageDescription ? { imageDescription } : {},
+				...data.raw.imageData ? { imageRef: data.raw.imageData } : {}
 			};
 			await kv.set(KV.observations(data.sessionId), data.observationId, compressed);
 			getSearchIndex().add(compressed);
@@ -3074,52 +4187,6 @@ function buildSummaryPrompt(observations) {
 	return `Session observations (${observations.length} total):\n\n${lines.join("\n\n---\n\n")}`;
 }
 
-//#endregion
-//#region src/functions/audit.ts
-async function recordAudit(kv, operation, functionId, targetIds, details = {}, qualityScore, userId) {
-	const entry = {
-		id: generateId("aud"),
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		operation,
-		userId,
-		functionId,
-		targetIds,
-		details,
-		qualityScore
-	};
-	await kv.set(KV.audit, entry.id, entry);
-	return entry;
-}
-async function safeAudit(kv, operation, functionId, targetIds, details = {}, qualityScore, userId) {
-	try {
-		await recordAudit(kv, operation, functionId, targetIds, details, qualityScore, userId);
-	} catch (err) {
-		try {
-			logger.warn("audit write failed", {
-				functionId,
-				operation,
-				targetIds,
-				error: err instanceof Error ? err.message : String(err)
-			});
-		} catch {}
-	}
-}
-async function queryAudit(kv, filter) {
-	let entries = [...await kv.list(KV.audit)].sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-	if (filter?.operation) entries = entries.filter((e) => e.operation === filter.operation);
-	if (filter?.dateFrom) {
-		const from = new Date(filter.dateFrom).getTime();
-		if (Number.isNaN(from)) throw new Error(`Invalid dateFrom: ${filter.dateFrom}`);
-		entries = entries.filter((e) => new Date(e.timestamp).getTime() >= from);
-	}
-	if (filter?.dateTo) {
-		const to = new Date(filter.dateTo).getTime();
-		if (Number.isNaN(to)) throw new Error(`Invalid dateTo: ${filter.dateTo}`);
-		entries = entries.filter((e) => new Date(e.timestamp).getTime() <= to);
-	}
-	return entries.slice(0, filter?.limit || 100);
-}
-
 //#endregion
 //#region src/functions/summarize.ts
 function parseSummaryXml(xml, sessionId, project, obsCount) {
@@ -3161,9 +4228,33 @@ function registerSummarizeFunction(sdk, kv, provider, metricsStore) {
 				error: "no_observations"
 			};
 		}
+		if (provider.name === "noop") {
+			logger.info("Summarize skipped — no LLM provider configured", { sessionId });
+			return {
+				success: false,
+				error: "no_provider",
+				reason: "No LLM provider key set; Summarize is a no-op. Set ANTHROPIC_API_KEY (or GEMINI/OPENROUTER/MINIMAX) in ~/.agentmemory/.env to enable."
+			};
+		}
 		try {
 			const prompt = buildSummaryPrompt(compressed);
-			const summary = parseSummaryXml(await provider.summarize(SUMMARY_SYSTEM, prompt), sessionId, session.project, compressed.length);
+			const response = await provider.summarize(SUMMARY_SYSTEM, prompt);
+			if (!response || !response.trim()) {
+				const latencyMs = Date.now() - startMs;
+				if (metricsStore) await metricsStore.record("mem::summarize", latencyMs, false);
+				logger.warn("Empty provider response on summarize", {
+					sessionId,
+					provider: provider.name,
+					promptBytes: prompt.length,
+					systemBytes: SUMMARY_SYSTEM.length,
+					observationCount: compressed.length
+				});
+				return {
+					success: false,
+					error: "empty_provider_response"
+				};
+			}
+			const summary = parseSummaryXml(response, sessionId, session.project, compressed.length);
 			if (!summary) {
 				const latencyMs = Date.now() - startMs;
 				if (metricsStore) await metricsStore.record("mem::summarize", latencyMs, false);
@@ -3750,14 +4841,20 @@ function registerRememberFunction(sdk, kv) {
 		const deletedMemoryIds = [];
 		const deletedObservationIds = [];
 		let deletedSession = false;
+		const { decrementImageRef } = await Promise.resolve().then(() => image_refs_exports);
 		if (data.memoryId) {
+			const mem = await kv.get(KV.memories, data.memoryId);
 			await kv.delete(KV.memories, data.memoryId);
+			if (mem?.imageRef) await decrementImageRef(kv, sdk, mem.imageRef);
 			await deleteAccessLog(kv, data.memoryId);
 			deletedMemoryIds.push(data.memoryId);
 			deleted++;
 		}
 		if (data.sessionId && data.observationIds && data.observationIds.length > 0) for (const obsId of data.observationIds) {
+			const obs = await kv.get(KV.observations(data.sessionId), obsId);
 			await kv.delete(KV.observations(data.sessionId), obsId);
+			if (obs?.imageData) await decrementImageRef(kv, sdk, obs.imageData);
+			if (obs?.imageRef && obs.imageRef !== obs.imageData) await decrementImageRef(kv, sdk, obs.imageRef);
 			deletedObservationIds.push(obsId);
 			deleted++;
 		}
@@ -3765,6 +4862,8 @@ function registerRememberFunction(sdk, kv) {
 			const observations = await kv.list(KV.observations(data.sessionId));
 			for (const obs of observations) {
 				await kv.delete(KV.observations(data.sessionId), obs.id);
+				if (obs.imageData) await decrementImageRef(kv, sdk, obs.imageData);
+				if (obs.imageRef && obs.imageRef !== obs.imageData) await decrementImageRef(kv, sdk, obs.imageRef);
 				deletedObservationIds.push(obs.id);
 				deleted++;
 			}
@@ -3801,6 +4900,7 @@ const DEFAULTS$1 = {
 function registerEvictFunction(sdk, kv) {
 	sdk.registerFunction("mem::evict", async (data) => {
 		const dryRun = data?.dryRun ?? false;
+		const { decrementImageRef } = await Promise.resolve().then(() => image_refs_exports);
 		const configOverride = await kv.get(KV.config, "eviction").catch(() => null);
 		const cfg = {
 			...DEFAULTS$1,
@@ -3859,6 +4959,8 @@ function registerEvictFunction(sdk, kv) {
 						});
 						continue;
 					}
+					if (o.imageData) await decrementImageRef(kv, sdk, o.imageData);
+					if (o.imageRef && o.imageRef !== o.imageData) await decrementImageRef(kv, sdk, o.imageRef);
 					await recordAudit(kv, "delete", "mem::evict", [o.id], {
 						resource: "observation",
 						reason: "low_importance_old_observation",
@@ -3888,6 +4990,8 @@ function registerEvictFunction(sdk, kv) {
 					});
 					continue;
 				}
+				if (o.imageData) await decrementImageRef(kv, sdk, o.imageData);
+				if (o.imageRef && o.imageRef !== o.imageData) await decrementImageRef(kv, sdk, o.imageRef);
 				await recordAudit(kv, "delete", "mem::evict", [o.id], {
 					resource: "observation",
 					reason: "project_observation_cap",
@@ -3917,6 +5021,7 @@ function registerEvictFunction(sdk, kv) {
 						});
 						continue;
 					}
+					if (mem.imageRef) await decrementImageRef(kv, sdk, mem.imageRef);
 					await recordAudit(kv, "delete", "mem::evict", [mem.id], {
 						resource: "memory",
 						reason: "expired_memory",
@@ -3940,6 +5045,7 @@ function registerEvictFunction(sdk, kv) {
 						});
 						continue;
 					}
+					if (mem.imageRef) await decrementImageRef(kv, sdk, mem.imageRef);
 					await recordAudit(kv, "delete", "mem::evict", [mem.id], {
 						resource: "memory",
 						reason: "old_non_latest_memory",
@@ -4397,6 +5503,7 @@ function registerAutoForgetFunction(sdk, kv) {
 	sdk.registerFunction("mem::auto-forget", async (data) => {
 		const dryRun = data?.dryRun ?? false;
 		const now = Date.now();
+		const { decrementImageRef } = await Promise.resolve().then(() => image_refs_exports);
 		const result = {
 			ttlExpired: [],
 			contradictions: [],
@@ -4410,6 +5517,7 @@ function registerAutoForgetFunction(sdk, kv) {
 				result.ttlExpired.push(mem.id);
 				deletedIds.add(mem.id);
 				if (!dryRun) {
+					if (mem.imageRef) await decrementImageRef(kv, sdk, mem.imageRef);
 					await kv.delete(KV.memories, mem.id);
 					await recordAudit(kv, "delete", "mem::auto-forget", [mem.id], {
 						resource: "memory",
@@ -4478,13 +5586,23 @@ function registerAutoForgetFunction(sdk, kv) {
 			if (now - new Date(obs.timestamp).getTime() > 180 * MS_PER_DAY && (obs.importance ?? 5) <= 2) {
 				result.lowValueObs.push(obs.id);
 				if (!dryRun) {
-					await kv.delete(KV.observations(sessions[i].id), obs.id).catch(() => {});
-					await recordAudit(kv, "delete", "mem::auto-forget", [obs.id], {
-						resource: "observation",
-						reason: "auto-forget low-value observation",
-						sessionId: sessions[i].id,
-						timestamp: obs.timestamp
-					});
+					let deletedOk = false;
+					try {
+						await kv.delete(KV.observations(sessions[i].id), obs.id);
+						deletedOk = true;
+					} catch {
+						deletedOk = false;
+					}
+					if (deletedOk) {
+						if (obs.imageData) await decrementImageRef(kv, sdk, obs.imageData);
+						if (obs.imageRef && obs.imageRef !== obs.imageData) await decrementImageRef(kv, sdk, obs.imageRef);
+						await recordAudit(kv, "delete", "mem::auto-forget", [obs.id], {
+							resource: "observation",
+							reason: "auto-forget low-value observation",
+							sessionId: sessions[i].id,
+							timestamp: obs.timestamp
+						});
+					}
 				}
 			}
 		}
@@ -4500,7 +5618,7 @@ function registerAutoForgetFunction(sdk, kv) {
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.9.0";
+const VERSION = "0.9.2";
 
 //#endregion
 //#region src/functions/export-import.ts
@@ -4618,7 +5736,9 @@ function registerExportImportFunction(sdk, kv) {
 			"0.8.11",
 			"0.8.12",
 			"0.8.13",
-			"0.9.0"
+			"0.9.0",
+			"0.9.1",
+			"0.9.2"
 		]).has(importData.version)) return {
 			success: false,
 			error: `Unsupported export version: ${importData.version}`
@@ -10975,6 +12095,7 @@ function registerRetentionFunctions(sdk, kv) {
 		const threshold = typeof data?.threshold === "number" && Number.isFinite(data.threshold) ? data.threshold : DEFAULT_DECAY.tierThresholds.cold;
 		const maxEvictRaw = typeof data?.maxEvict === "number" && Number.isInteger(data.maxEvict) ? data.maxEvict : 50;
 		const maxEvict = Math.min(1e3, Math.max(0, maxEvictRaw));
+		const { decrementImageRef } = await Promise.resolve().then(() => image_refs_exports);
 		const candidates = (await kv.list(KV.retentionScores)).filter((s) => s.score < threshold).sort((a, b) => a.score - b.score).slice(0, maxEvict);
 		if (data?.dryRun) return {
 			success: true,
@@ -11006,6 +12127,8 @@ function registerRetentionFunctions(sdk, kv) {
 				resolvedSource = "semantic";
 			}
 			if (!scope || !resolvedSource) continue;
+			const mem = await kv.get(scope, candidate.memoryId);
+			if (mem && mem.imageRef) await decrementImageRef(kv, sdk, mem.imageRef);
 			await kv.delete(scope, candidate.memoryId);
 			await kv.delete(KV.retentionScores, candidate.memoryId);
 			await deleteAccessLog(kv, candidate.memoryId);
@@ -11443,6 +12566,92 @@ function rawFromCompressed(obs) {
 		}
 	};
 }
+const LESSON_PATTERNS = [/\b(always|never|don'?t|do not|make sure|remember to|note:|caveat:|warning:)\b[^.\n]{10,200}[.!\n]/gi, /\b(prefer|avoid)\s[^.\n]{10,200}[.!\n]/gi];
+async function deriveCrystalAndLessons(kv, sessionId, project, rawObs, compressed, firstPrompt) {
+	if (rawObs.length === 0) return;
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	const files = /* @__PURE__ */ new Set();
+	const tools = /* @__PURE__ */ new Set();
+	for (const c of compressed) {
+		for (const f of c.files || []) files.add(f);
+		if (c.type && c.type !== "conversation" && c.title) tools.add(c.title);
+	}
+	const assistantTexts = [];
+	const userPrompts = [];
+	for (const r of rawObs) {
+		if (typeof r.assistantResponse === "string" && r.assistantResponse.trim()) assistantTexts.push(r.assistantResponse);
+		if (typeof r.userPrompt === "string" && r.userPrompt.trim()) userPrompts.push(r.userPrompt);
+	}
+	const lessonMatches = /* @__PURE__ */ new Map();
+	for (const text of assistantTexts.concat(userPrompts).slice(0, 200)) for (const pat of LESSON_PATTERNS) {
+		pat.lastIndex = 0;
+		let m;
+		while ((m = pat.exec(text)) !== null && lessonMatches.size < 40) {
+			const snippet = m[0].replace(/\s+/g, " ").trim();
+			if (snippet.length >= 20 && snippet.length <= 220) {
+				const key = snippet.toLowerCase();
+				if (!lessonMatches.has(key)) lessonMatches.set(key, snippet);
+			}
+		}
+	}
+	const lessonEntries = Array.from(lessonMatches.values()).slice(0, 20);
+	const lessonIds = [];
+	for (const content of lessonEntries) {
+		const lessonId = fingerprintId("lesson", content.trim().toLowerCase());
+		try {
+			const existing = await kv.get(KV.lessons, lessonId);
+			if (existing) {
+				const existingSources = existing.sourceIds || [];
+				const mergedSources = existingSources.includes(sessionId) ? existingSources : [...existingSources, sessionId];
+				const existingTags = existing.tags || [];
+				const mergedTags = existingTags.includes("auto-import") ? existingTags : [...existingTags, "auto-import"];
+				const merged = {
+					...existing,
+					sourceIds: mergedSources,
+					tags: mergedTags,
+					reinforcements: (existing.reinforcements || 0) + 1,
+					updatedAt: createdAt,
+					lastReinforcedAt: createdAt
+				};
+				await kv.set(KV.lessons, lessonId, merged);
+			} else {
+				const lesson = {
+					id: lessonId,
+					content,
+					context: firstPrompt || project,
+					confidence: .4,
+					reinforcements: 0,
+					source: "consolidation",
+					sourceIds: [sessionId],
+					project,
+					tags: ["auto-import"],
+					createdAt,
+					updatedAt: createdAt,
+					decayRate: .05
+				};
+				await kv.set(KV.lessons, lessonId, lesson);
+			}
+			lessonIds.push(lessonId);
+		} catch {}
+	}
+	const crystalId = fingerprintId("crystal", sessionId);
+	const narrativePreview = firstPrompt ? firstPrompt.slice(0, 300) : compressed.slice(0, 5).map((c) => c.narrative || c.title).filter(Boolean).join(" · ").slice(0, 300);
+	try {
+		const existingCrystal = await kv.get(KV.crystals, crystalId);
+		const crystal = {
+			id: crystalId,
+			narrative: narrativePreview || `Session ${sessionId.slice(0, 12)} (${rawObs.length} observations)`,
+			keyOutcomes: Array.from(tools).slice(0, 8),
+			filesAffected: Array.from(files).slice(0, 20),
+			lessons: lessonIds,
+			sourceActionIds: existingCrystal?.sourceActionIds ?? [],
+			sessionId,
+			project,
+			createdAt: existingCrystal?.createdAt ?? createdAt
+		};
+		await kv.set(KV.crystals, crystalId, crystal);
+	} catch {}
+}
 function isRawShape(o) {
 	if (!o || typeof o !== "object") return false;
 	return typeof o.hookType === "string";
@@ -11553,6 +12762,8 @@ function registerReplayFunctions(sdk, kv) {
 			}
 			const parsed = parseJsonlText(text, generateId("sess"));
 			if (parsed.observations.length === 0) continue;
+			const firstPromptObs = parsed.observations.find((o) => typeof o.userPrompt === "string" && o.userPrompt.trim().length > 0);
+			const firstPrompt = firstPromptObs?.userPrompt ? firstPromptObs.userPrompt.replace(/\s+/g, " ").trim().slice(0, 200) : void 0;
 			const existing = await kv.get(KV.sessions, parsed.sessionId);
 			if (existing) {
 				existing.observationCount = (existing.observationCount || 0) + parsed.observations.length;
@@ -11560,6 +12771,7 @@ function registerReplayFunctions(sdk, kv) {
 				if (existing.status === "active") existing.status = "completed";
 				const existingTags = existing.tags || [];
 				if (!existingTags.includes("jsonl-import")) existing.tags = [...existingTags, "jsonl-import"];
+				if (!existing.firstPrompt && firstPrompt) existing.firstPrompt = firstPrompt;
 				await kv.set(KV.sessions, existing.id, existing);
 			} else {
 				const session = {
@@ -11570,13 +12782,22 @@ function registerReplayFunctions(sdk, kv) {
 					endedAt: parsed.endedAt,
 					status: "completed",
 					observationCount: parsed.observations.length,
-					tags: ["jsonl-import"]
+					tags: ["jsonl-import"],
+					firstPrompt
 				};
 				await kv.set(KV.sessions, session.id, session);
 			}
-			await Promise.all(parsed.observations.map((obs) => kv.set(KV.observations(parsed.sessionId), obs.id, obs)));
+			const searchIndex = getSearchIndex();
+			const compressed = [];
+			await Promise.all(parsed.observations.map(async (obs) => {
+				const synthetic = buildSyntheticCompression(obs);
+				compressed.push(synthetic);
+				await kv.set(KV.observations(parsed.sessionId), obs.id, synthetic);
+				searchIndex.add(synthetic);
+			}));
 			observationCount += parsed.observations.length;
 			sessionIds.push(parsed.sessionId);
+			await deriveCrystalAndLessons(kv, parsed.sessionId, parsed.project, parsed.observations, compressed, firstPrompt);
 		}
 		await safeAudit(kv, "import", "mem::replay::import-jsonl", sessionIds, {
 			source: "jsonl",
@@ -11610,6 +12831,7 @@ function evaluateHealth(snapshot, config = {}) {
 		...config
 	};
 	const alerts = [];
+	const notes = [];
 	let critical = false;
 	let degraded = false;
 	if (snapshot.connectionState === "disconnected" || snapshot.connectionState === "failed") {
@@ -11643,10 +12865,11 @@ function evaluateHealth(snapshot, config = {}) {
 	} else if (memPercent > cfg.memoryWarnPercent && rssAboveFloor) {
 		alerts.push(`memory_warn_${Math.round(memPercent)}%_rss${memMb}mb`);
 		degraded = true;
-	} else if (memPercent > cfg.memoryWarnPercent) alerts.push(`memory_heap_tight_${Math.round(memPercent)}%_rss${memMb}mb`);
+	} else if (memPercent > cfg.memoryWarnPercent) notes.push(`memory_heap_tight_${Math.round(memPercent)}%_rss${memMb}mb`);
 	return {
 		status: critical ? "critical" : degraded ? "degraded" : "healthy",
-		alerts
+		alerts,
+		notes
 	};
 }
 
@@ -11723,6 +12946,7 @@ function registerHealthMonitor(sdk, kv) {
 		const evaluated = evaluateHealth(snapshot);
 		snapshot.status = evaluated.status;
 		snapshot.alerts = evaluated.alerts;
+		snapshot.notes = evaluated.notes;
 		await kv.set(KV.health, "latest", snapshot).catch(() => {});
 		return snapshot;
 	}
@@ -11765,6 +12989,7 @@ function buildViewerCsp(nonce) {
 
 //#endregion
 //#region src/viewer/document.ts
+const VIEWER_VERSION_PLACEHOLDER = "__AGENTMEMORY_VERSION__";
 function loadViewerTemplate() {
 	const base = dirname(fileURLToPath(import.meta.url));
 	const candidates = [
@@ -11783,7 +13008,7 @@ function renderViewerDocument() {
 	const nonce = createViewerNonce();
 	return {
 		found: true,
-		html: template.replaceAll(VIEWER_NONCE_PLACEHOLDER, nonce),
+		html: template.replaceAll(VIEWER_NONCE_PLACEHOLDER, nonce).replaceAll(VIEWER_VERSION_PLACEHOLDER, VERSION),
 		csp: buildViewerCsp(nonce)
 	};
 }
@@ -12065,9 +13290,14 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 	sdk.registerFunction("api::replay::sessions", async (req) => {
 		const authErr = checkAuth(req, secret);
 		if (authErr) return authErr;
+		const sessions = await kv.list(KV.sessions);
+		sessions.sort((a, b) => (b.startedAt || "").localeCompare(a.startedAt || ""));
 		return {
 			status_code: 200,
-			body: await sdk.trigger({ function_id: "mem::replay::sessions" })
+			body: {
+				success: true,
+				sessions
+			}
 		};
 	});
 	sdk.registerTrigger({
@@ -12862,13 +14092,16 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 		const parsedLimit = parseOptionalInt(req.query_params?.["limit"]);
 		return {
 			status_code: 200,
-			body: await sdk.trigger({
-				function_id: "mem::audit-query",
-				payload: {
-					operation: req.query_params?.["operation"],
-					limit: parsedLimit ?? 50
-				}
-			})
+			body: {
+				entries: await sdk.trigger({
+					function_id: "mem::audit-query",
+					payload: {
+						operation: req.query_params?.["operation"],
+						limit: parsedLimit ?? 50
+					}
+				}),
+				success: true
+			}
 		};
 	});
 	sdk.registerTrigger({
@@ -12960,64 +14193,444 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 			};
 		} catch {
 			return {
-				status_code: 404,
-				body: { error: "Snapshots not enabled" }
+				status_code: 404,
+				body: { error: "Snapshots not enabled" }
+			};
+		}
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::snapshot-create",
+		config: {
+			api_path: "/agentmemory/snapshot/create",
+			http_method: "POST"
+		}
+	});
+	sdk.registerFunction("api::snapshot-restore", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		if (!req.body?.commitHash) return {
+			status_code: 400,
+			body: { error: "commitHash is required" }
+		};
+		try {
+			return {
+				status_code: 200,
+				body: await sdk.trigger({
+					function_id: "mem::snapshot-restore",
+					payload: req.body
+				})
+			};
+		} catch {
+			return {
+				status_code: 404,
+				body: { error: "Snapshots not enabled" }
+			};
+		}
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::snapshot-restore",
+		config: {
+			api_path: "/agentmemory/snapshot/restore",
+			http_method: "POST"
+		}
+	});
+	sdk.registerFunction("api::memories", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const memories = await kv.list(KV.memories);
+		return {
+			status_code: 200,
+			body: { memories: req.query_params?.["latest"] === "true" ? memories.filter((m) => m.isLatest) : memories }
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::memories",
+		config: {
+			api_path: "/agentmemory/memories",
+			http_method: "GET"
+		}
+	});
+	sdk.registerFunction("api::semantic-list", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		return {
+			status_code: 200,
+			body: { semantic: await kv.list(KV.semantic) }
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::semantic-list",
+		config: {
+			api_path: "/agentmemory/semantic",
+			http_method: "GET"
+		}
+	});
+	sdk.registerFunction("api::procedural-list", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		return {
+			status_code: 200,
+			body: { procedural: await kv.list(KV.procedural) }
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::procedural-list",
+		config: {
+			api_path: "/agentmemory/procedural",
+			http_method: "GET"
+		}
+	});
+	sdk.registerFunction("api::relations-list", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		return {
+			status_code: 200,
+			body: { relations: await kv.list(KV.relations) }
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::relations-list",
+		config: {
+			api_path: "/agentmemory/relations",
+			http_method: "GET"
+		}
+	});
+	sdk.registerFunction("api::vision-search", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const body = req.body ?? {};
+		const queryText = asNonEmptyString$1(body["queryText"]);
+		const queryImageRef = asNonEmptyString$1(body["queryImageRef"]);
+		const queryImageBase64 = asNonEmptyString$1(body["queryImageBase64"]);
+		const sessionId = asNonEmptyString$1(body["sessionId"]);
+		if (!queryText && !queryImageRef && !queryImageBase64) return {
+			status_code: 400,
+			body: { error: "queryText, queryImageRef, or queryImageBase64 required" }
+		};
+		const topKParsed = parseOptionalPositiveInt(body["topK"]);
+		if (topKParsed === null) return {
+			status_code: 400,
+			body: { error: "topK must be a positive integer" }
+		};
+		const payload = {};
+		if (queryText) payload["queryText"] = queryText;
+		if (queryImageRef) payload["queryImageRef"] = queryImageRef;
+		if (queryImageBase64) payload["queryImageBase64"] = queryImageBase64;
+		if (sessionId) payload["sessionId"] = sessionId;
+		if (topKParsed !== void 0) payload["topK"] = Math.min(50, topKParsed);
+		const result = await sdk.trigger({
+			function_id: "mem::vision-search",
+			payload
+		});
+		const resp = result;
+		if (resp?.success === false) return {
+			status_code: resp.error?.includes("disabled") ? 503 : 400,
+			body: resp
+		};
+		return {
+			status_code: 200,
+			body: result
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::vision-search",
+		config: {
+			api_path: "/agentmemory/vision-search",
+			http_method: "POST"
+		}
+	});
+	sdk.registerFunction("api::vision-embed", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const body = req.body ?? {};
+		const imageRef = asNonEmptyString$1(body["imageRef"]);
+		const sessionId = asNonEmptyString$1(body["sessionId"]);
+		const observationId = asNonEmptyString$1(body["observationId"]);
+		if (!imageRef) return {
+			status_code: 400,
+			body: { error: "imageRef is required" }
+		};
+		const payload = { imageRef };
+		if (sessionId) payload["sessionId"] = sessionId;
+		if (observationId) payload["observationId"] = observationId;
+		const result = await sdk.trigger({
+			function_id: "mem::vision-embed",
+			payload
+		});
+		const resp = result;
+		if (resp?.success === false) return {
+			status_code: resp.error?.includes("disabled") ? 503 : 400,
+			body: resp
+		};
+		return {
+			status_code: 200,
+			body: result
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::vision-embed",
+		config: {
+			api_path: "/agentmemory/vision-embed",
+			http_method: "POST"
+		}
+	});
+	sdk.registerFunction("api::slot-list", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		return {
+			status_code: 200,
+			body: await sdk.trigger({
+				function_id: "mem::slot-list",
+				payload: {}
+			})
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::slot-list",
+		config: {
+			api_path: "/agentmemory/slots",
+			http_method: "GET"
+		}
+	});
+	sdk.registerFunction("api::slot-get", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const label = asNonEmptyString$1(req.query_params?.["label"]);
+		if (!label) return {
+			status_code: 400,
+			body: { error: "label query param required" }
+		};
+		const result = await sdk.trigger({
+			function_id: "mem::slot-get",
+			payload: { label }
+		});
+		const resp = result;
+		if (resp?.success === false) return {
+			status_code: resp.error?.includes("not found") ? 404 : 400,
+			body: resp
+		};
+		return {
+			status_code: 200,
+			body: result
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::slot-get",
+		config: {
+			api_path: "/agentmemory/slot",
+			http_method: "GET"
+		}
+	});
+	sdk.registerFunction("api::slot-create", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const body = req.body ?? {};
+		const label = asNonEmptyString$1(body["label"]);
+		if (!label) return {
+			status_code: 400,
+			body: { error: "label required" }
+		};
+		if (body["content"] !== void 0 && typeof body["content"] !== "string") return {
+			status_code: 400,
+			body: { error: "content must be a string" }
+		};
+		if (body["description"] !== void 0 && typeof body["description"] !== "string") return {
+			status_code: 400,
+			body: { error: "description must be a string" }
+		};
+		if (body["pinned"] !== void 0 && typeof body["pinned"] !== "boolean") return {
+			status_code: 400,
+			body: { error: "pinned must be a boolean" }
+		};
+		if (body["scope"] !== void 0 && body["scope"] !== "project" && body["scope"] !== "global") return {
+			status_code: 400,
+			body: { error: "scope must be 'project' or 'global'" }
+		};
+		const sizeLimit = parseOptionalPositiveInt(body["sizeLimit"]);
+		if (sizeLimit === null) return {
+			status_code: 400,
+			body: { error: "sizeLimit must be a positive integer" }
+		};
+		if (sizeLimit !== void 0 && sizeLimit > 2e4) return {
+			status_code: 400,
+			body: { error: "sizeLimit must be <= 20000" }
+		};
+		const payload = { label };
+		if (typeof body["content"] === "string") payload["content"] = body["content"];
+		if (typeof body["description"] === "string") payload["description"] = body["description"];
+		if (sizeLimit !== void 0) payload["sizeLimit"] = sizeLimit;
+		if (typeof body["pinned"] === "boolean") payload["pinned"] = body["pinned"];
+		if (body["scope"] === "project" || body["scope"] === "global") payload["scope"] = body["scope"];
+		const result = await sdk.trigger({
+			function_id: "mem::slot-create",
+			payload
+		});
+		const resp = result;
+		if (resp?.success === false) return {
+			status_code: resp.error?.includes("exists") ? 409 : 400,
+			body: resp
+		};
+		return {
+			status_code: 201,
+			body: result
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::slot-create",
+		config: {
+			api_path: "/agentmemory/slot",
+			http_method: "POST"
+		}
+	});
+	sdk.registerFunction("api::slot-append", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const body = req.body ?? {};
+		const label = asNonEmptyString$1(body["label"]);
+		const text = typeof body["text"] === "string" ? body["text"] : null;
+		if (!label || !text) return {
+			status_code: 400,
+			body: { error: "label and text required" }
+		};
+		const result = await sdk.trigger({
+			function_id: "mem::slot-append",
+			payload: {
+				label,
+				text
+			}
+		});
+		const resp = result;
+		if (resp?.success === false) {
+			const notFound = resp.error?.includes("not found");
+			const overLimit = resp.error?.includes("exceed");
+			return {
+				status_code: notFound ? 404 : overLimit ? 413 : 400,
+				body: resp
 			};
 		}
+		return {
+			status_code: 200,
+			body: result
+		};
 	});
 	sdk.registerTrigger({
 		type: "http",
-		function_id: "api::snapshot-create",
+		function_id: "api::slot-append",
 		config: {
-			api_path: "/agentmemory/snapshot/create",
+			api_path: "/agentmemory/slot/append",
 			http_method: "POST"
 		}
 	});
-	sdk.registerFunction("api::snapshot-restore", async (req) => {
+	sdk.registerFunction("api::slot-replace", async (req) => {
 		const authErr = checkAuth(req, secret);
 		if (authErr) return authErr;
-		if (!req.body?.commitHash) return {
+		const body = req.body ?? {};
+		const label = asNonEmptyString$1(body["label"]);
+		const content = body["content"];
+		if (!label || typeof content !== "string") return {
 			status_code: 400,
-			body: { error: "commitHash is required" }
+			body: { error: "label and content (string) required" }
 		};
-		try {
-			return {
-				status_code: 200,
-				body: await sdk.trigger({
-					function_id: "mem::snapshot-restore",
-					payload: req.body
-				})
-			};
-		} catch {
+		const result = await sdk.trigger({
+			function_id: "mem::slot-replace",
+			payload: {
+				label,
+				content
+			}
+		});
+		const resp = result;
+		if (resp?.success === false) {
+			const notFound = resp.error?.includes("not found");
+			const overLimit = resp.error?.includes("exceed");
 			return {
-				status_code: 404,
-				body: { error: "Snapshots not enabled" }
+				status_code: notFound ? 404 : overLimit ? 413 : 400,
+				body: resp
 			};
 		}
+		return {
+			status_code: 200,
+			body: result
+		};
 	});
 	sdk.registerTrigger({
 		type: "http",
-		function_id: "api::snapshot-restore",
+		function_id: "api::slot-replace",
 		config: {
-			api_path: "/agentmemory/snapshot/restore",
+			api_path: "/agentmemory/slot/replace",
 			http_method: "POST"
 		}
 	});
-	sdk.registerFunction("api::memories", async (req) => {
+	sdk.registerFunction("api::slot-delete", async (req) => {
 		const authErr = checkAuth(req, secret);
 		if (authErr) return authErr;
-		const memories = await kv.list(KV.memories);
+		const label = asNonEmptyString$1(req.query_params?.["label"]);
+		if (!label) return {
+			status_code: 400,
+			body: { error: "label query param required" }
+		};
+		const result = await sdk.trigger({
+			function_id: "mem::slot-delete",
+			payload: { label }
+		});
+		const resp = result;
+		if (resp?.success === false) return {
+			status_code: resp.error?.includes("not found") ? 404 : 400,
+			body: resp
+		};
 		return {
 			status_code: 200,
-			body: { memories: req.query_params?.["latest"] === "true" ? memories.filter((m) => m.isLatest) : memories }
+			body: result
 		};
 	});
 	sdk.registerTrigger({
 		type: "http",
-		function_id: "api::memories",
+		function_id: "api::slot-delete",
 		config: {
-			api_path: "/agentmemory/memories",
-			http_method: "GET"
+			api_path: "/agentmemory/slot",
+			http_method: "DELETE"
+		}
+	});
+	sdk.registerFunction("api::slot-reflect", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const body = req.body ?? {};
+		const sessionId = asNonEmptyString$1(body["sessionId"]);
+		if (!sessionId) return {
+			status_code: 400,
+			body: { error: "sessionId required" }
+		};
+		const maxObservations = parseOptionalPositiveInt(body["maxObservations"]);
+		if (maxObservations === null) return {
+			status_code: 400,
+			body: { error: "maxObservations must be a positive integer" }
+		};
+		const payload = { sessionId };
+		if (maxObservations !== void 0) payload["maxObservations"] = maxObservations;
+		return {
+			status_code: 200,
+			body: await sdk.trigger({
+				function_id: "mem::slot-reflect",
+				payload
+			})
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::slot-reflect",
+		config: {
+			api_path: "/agentmemory/slot/reflect",
+			http_method: "POST"
 		}
 	});
 	sdk.registerFunction("api::action-create", async (req) => {
@@ -13254,9 +14867,9 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 	sdk.registerFunction("api::routine-create", async (req) => {
 		const authErr = checkAuth(req, secret);
 		if (authErr) return authErr;
-		if (!req.body?.name) return {
+		if (!req.body?.name || !req.body?.steps) return {
 			status_code: 400,
-			body: { error: "name is required" }
+			body: { error: "name and steps are required" }
 		};
 		return {
 			status_code: 201,
@@ -14505,10 +16118,21 @@ function registerEventTriggers(sdk, kv) {
 		function_id: "event::observation",
 		config: { topic: "agentmemory.observation" }
 	});
-	sdk.registerFunction("event::session::stopped", async (data) => sdk.trigger({
-		function_id: "mem::summarize",
-		payload: data
-	}));
+	sdk.registerFunction("event::session::stopped", async (data) => {
+		const summary = await sdk.trigger({
+			function_id: "mem::summarize",
+			payload: data
+		});
+		if (isReflectEnabled()) try {
+			sdk.triggerVoid("mem::slot-reflect", { sessionId: data.sessionId });
+		} catch (err) {
+			logger.warn("slot-reflect triggerVoid failed", {
+				sessionId: data.sessionId,
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+		return summary;
+	});
 	sdk.registerTrigger({
 		type: "durable:subscriber",
 		function_id: "event::session::stopped",
@@ -14687,6 +16311,35 @@ const CORE_TOOLS = [
 			required: ["query"]
 		}
 	},
+	{
+		name: "memory_vision_search",
+		description: "Cross-modal image search via CLIP embeddings. Pass queryText to find screenshots matching a description, or queryImageBase64/queryImageRef to find similar images. Requires AGENTMEMORY_IMAGE_EMBEDDINGS=true.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				queryText: {
+					type: "string",
+					description: "Text query (e.g. 'login form with error banner')"
+				},
+				queryImageRef: {
+					type: "string",
+					description: "Absolute path to a stored image to match against"
+				},
+				queryImageBase64: {
+					type: "string",
+					description: "Raw base64 image bytes or data URL"
+				},
+				topK: {
+					type: "number",
+					description: "Max results (default 10, max 50)"
+				},
+				sessionId: {
+					type: "string",
+					description: "Filter to a single session"
+				}
+			}
+		}
+	},
 	{
 		name: "memory_timeline",
 		description: "Chronological observations around an anchor point.",
@@ -15474,6 +17127,110 @@ const V073_TOOLS = [{
 		}
 	}
 }];
+const V010_SLOTS_TOOLS = [
+	{
+		name: "memory_slot_list",
+		description: "List all memory slots (pinned + project + global). Slots are editable, size-limited memory units the agent can read and modify across sessions.",
+		inputSchema: {
+			type: "object",
+			properties: {}
+		}
+	},
+	{
+		name: "memory_slot_get",
+		description: "Read a single slot by label.",
+		inputSchema: {
+			type: "object",
+			properties: { label: {
+				type: "string",
+				description: "Slot label (e.g. 'persona', 'pending_items')"
+			} },
+			required: ["label"]
+		}
+	},
+	{
+		name: "memory_slot_create",
+		description: "Create a new slot. Reject if a slot with the same label already exists.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				label: {
+					type: "string",
+					description: "Slot label — lowercase, starts with letter, [a-z0-9_]"
+				},
+				content: {
+					type: "string",
+					description: "Initial content (default empty)"
+				},
+				sizeLimit: {
+					type: "number",
+					description: "Max chars (default 2000, hard cap 20000)"
+				},
+				description: {
+					type: "string",
+					description: "What this slot is for"
+				},
+				pinned: {
+					type: "string",
+					description: "'false' to exclude from context injection; default true"
+				},
+				scope: {
+					type: "string",
+					description: "'project' (default) or 'global' (shared across projects)"
+				}
+			},
+			required: ["label"]
+		}
+	},
+	{
+		name: "memory_slot_append",
+		description: "Append text to an existing slot. Fails with 413 if the append would exceed the slot's sizeLimit — agent must compact via memory_slot_replace first.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				label: {
+					type: "string",
+					description: "Slot label"
+				},
+				text: {
+					type: "string",
+					description: "Text to append"
+				}
+			},
+			required: ["label", "text"]
+		}
+	},
+	{
+		name: "memory_slot_replace",
+		description: "Replace slot content in place. Fails if content exceeds sizeLimit.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				label: {
+					type: "string",
+					description: "Slot label"
+				},
+				content: {
+					type: "string",
+					description: "New full content"
+				}
+			},
+			required: ["label", "content"]
+		}
+	},
+	{
+		name: "memory_slot_delete",
+		description: "Delete a slot. Seeded default slots can be deleted unless marked readOnly.",
+		inputSchema: {
+			type: "object",
+			properties: { label: {
+				type: "string",
+				description: "Slot label"
+			} },
+			required: ["label"]
+		}
+	}
+];
 const ESSENTIAL_TOOLS = new Set([
 	"memory_save",
 	"memory_recall",
@@ -15492,7 +17249,8 @@ function getAllTools() {
 		...V051_TOOLS,
 		...V061_TOOLS,
 		...V070_TOOLS,
-		...V073_TOOLS
+		...V073_TOOLS,
+		...V010_SLOTS_TOOLS
 	];
 }
 function getVisibleTools() {
@@ -15699,6 +17457,34 @@ function registerMcpEndpoints(sdk, kv, secret) {
 						}] }
 					};
 				}
+				case "memory_vision_search": {
+					const queryText = typeof args.queryText === "string" ? args.queryText : void 0;
+					const queryImageRef = typeof args.queryImageRef === "string" ? args.queryImageRef : void 0;
+					const queryImageBase64 = typeof args.queryImageBase64 === "string" ? args.queryImageBase64 : void 0;
+					if (!queryText && !queryImageRef && !queryImageBase64) return {
+						status_code: 400,
+						body: { error: "queryText, queryImageRef, or queryImageBase64 required" }
+					};
+					const topK = Math.max(1, Math.min(50, asNumber(args.topK, 10) ?? 10));
+					const sessionId = typeof args.sessionId === "string" ? args.sessionId : void 0;
+					const result = await sdk.trigger({
+						function_id: "mem::vision-search",
+						payload: {
+							queryText,
+							queryImageRef,
+							queryImageBase64,
+							topK,
+							sessionId
+						}
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
 				case "memory_timeline": {
 					if (typeof args.anchor !== "string" || !args.anchor.trim()) return {
 						status_code: 400,
@@ -16564,6 +18350,123 @@ function registerMcpEndpoints(sdk, kv, secret) {
 						}] }
 					};
 				}
+				case "memory_slot_list": {
+					const result = await sdk.trigger({
+						function_id: "mem::slot-list",
+						payload: {}
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
+				case "memory_slot_get": {
+					const label = asNonEmptyString(args.label);
+					if (!label) return {
+						status_code: 400,
+						body: { error: "label required" }
+					};
+					const result = await sdk.trigger({
+						function_id: "mem::slot-get",
+						payload: { label }
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
+				case "memory_slot_create": {
+					const label = asNonEmptyString(args.label);
+					if (!label) return {
+						status_code: 400,
+						body: { error: "label required" }
+					};
+					const payload = { label };
+					if (typeof args.content === "string") payload.content = args.content;
+					if (typeof args.description === "string") payload.description = args.description;
+					if (typeof args.sizeLimit === "number") payload.sizeLimit = args.sizeLimit;
+					if (args.pinned === false || args.pinned === "false") payload.pinned = false;
+					else if (args.pinned === true || args.pinned === "true") payload.pinned = true;
+					if (args.scope === "global" || args.scope === "project") payload.scope = args.scope;
+					const result = await sdk.trigger({
+						function_id: "mem::slot-create",
+						payload
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
+				case "memory_slot_append": {
+					const label = asNonEmptyString(args.label);
+					const text = typeof args.text === "string" ? args.text : null;
+					if (!label || !text) return {
+						status_code: 400,
+						body: { error: "label and text required" }
+					};
+					const result = await sdk.trigger({
+						function_id: "mem::slot-append",
+						payload: {
+							label,
+							text
+						}
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
+				case "memory_slot_replace": {
+					const label = asNonEmptyString(args.label);
+					if (!label || typeof args.content !== "string") return {
+						status_code: 400,
+						body: { error: "label and content (string) required" }
+					};
+					const result = await sdk.trigger({
+						function_id: "mem::slot-replace",
+						payload: {
+							label,
+							content: args.content
+						}
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
+				case "memory_slot_delete": {
+					const label = asNonEmptyString(args.label);
+					if (!label) return {
+						status_code: 400,
+						body: { error: "label required" }
+					};
+					const result = await sdk.trigger({
+						function_id: "mem::slot-delete",
+						payload: { label }
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}] }
+					};
+				}
 				default: return {
 					status_code: 400,
 					body: { error: `Unknown tool: ${name}` }
@@ -17218,11 +19121,13 @@ async function main() {
 	const fallbackConfig = loadFallbackConfig();
 	const provider = fallbackConfig.providers.length > 0 ? createFallbackProvider(config.provider, fallbackConfig) : createProvider(config.provider);
 	const embeddingProvider = createEmbeddingProvider();
+	const imageEmbeddingProvider = createImageEmbeddingProvider();
 	console.log(`[agentmemory] Starting worker v${VERSION}...`);
 	console.log(`[agentmemory] Engine: ${config.engineUrl}`);
 	console.log(`[agentmemory] Provider: ${config.provider.provider} (${config.provider.model})`);
 	if (embeddingProvider) console.log(`[agentmemory] Embedding provider: ${embeddingProvider.name} (${embeddingProvider.dimensions} dims)`);
 	else console.log(`[agentmemory] Embedding provider: none (BM25-only mode)`);
+	if (imageEmbeddingProvider) console.log(`[agentmemory] Image embedding provider: ${imageEmbeddingProvider.name} (${imageEmbeddingProvider.dimensions} dims) — vision-search active`);
 	console.log(`[agentmemory] REST API: http://localhost:${config.restPort}/agentmemory/*`);
 	console.log(`[agentmemory] Streams: ws://localhost:${config.streamsPort}`);
 	const sdk = registerWorker(config.engineUrl, {
@@ -17241,6 +19146,10 @@ async function main() {
 	initMetrics(hasGetMeter(sdk) ? sdk.getMeter.bind(sdk) : void 0);
 	registerPrivacyFunction(sdk);
 	registerObserveFunction(sdk, kv, dedupMap, config.maxObservationsPerSession);
+	registerImageQuotaCleanup(sdk, kv);
+	registerVisionSearchFunctions(sdk, kv, imageEmbeddingProvider);
+	if (isSlotsEnabled()) registerSlotsFunctions(sdk, kv);
+	registerDiskSizeManager(sdk, kv);
 	registerCompressFunction(sdk, kv, provider, metricsStore);
 	registerSearchFunction(sdk, kv);
 	registerContextFunction(sdk, kv, config.tokenBudget);
@@ -17307,6 +19216,7 @@ async function main() {
 	registerReplayFunctions(sdk, kv);
 	console.log(`[agentmemory] v0.6 advanced retrieval: sliding-window, query-expansion, temporal-graph, retention-scoring`);
 	console.log(`[agentmemory] Orchestration layer: actions, frontier, leases, routines, signals, checkpoints, flow-compress, mesh, branch-aware, sentinels, sketches, crystallize, diagnostics, facets`);
+	if (isSlotsEnabled()) console.log(`[agentmemory] Slots: enabled (pinned editable memory). Reflect on Stop hook: ${isReflectEnabled() ? "on" : "off"}`);
 	const snapshotConfig = loadSnapshotConfig();
 	if (snapshotConfig.enabled) {
 		registerSnapshotFunction(sdk, kv, snapshotConfig.dir);
@@ -17344,7 +19254,7 @@ async function main() {
 		}
 	}
 	console.log(`[agentmemory] Ready. ${embeddingProvider ? "Triple-stream (BM25+Vector+Graph)" : "BM25+Graph"} search active.`);
-	console.log(`[agentmemory] Endpoints: 107 REST + 44 MCP tools + 6 MCP resources + 3 MCP prompts`);
+	console.log(`[agentmemory] Endpoints: 107 REST + ${getAllTools().length} MCP tools + 6 MCP resources + 3 MCP prompts`);
 	const viewerServer = startViewerServer(config.restPort + 2, kv, sdk, secret, config.restPort);
 	const autoForgetIntervalMs = parseInt(process.env.AUTO_FORGET_INTERVAL_MS || "3600000", 10);
 	const consolidationIntervalMs = parseInt(process.env.CONSOLIDATION_INTERVAL_MS || "7200000", 10);