silentlake 3.0.0

package/dist/manager-DjPRm0yC.js

@@ -0,0 +1,4226 @@
+import { r as formatErrorMessage } from "./errors-BxyFnvP3.js";
+import { t as createSubsystemLogger } from "./subsystem-CUp-6QQf.js";
+import { t as isTruthyEnvValue } from "./env-BP70DGuy.js";
+import { E as truncateUtf16Safe, y as resolveUserPath } from "./utils-Bxk6BLTg.js";
+import { a as resolveAgentDir, p as resolveAgentWorkspaceDir } from "./agent-scope-DPP4Z_UU.js";
+import { r as normalizeProviderId } from "./provider-id-BpXo5t6v.js";
+import { a as hasConfiguredSecretInput, c as normalizeResolvedSecretInputString } from "./types.secrets-BWSeXrF4.js";
+import { t as normalizeOptionalSecretInput } from "./normalize-secret-input-_PgpexOG.js";
+import { c as resolveSessionTranscriptsDirForAgent } from "./paths-CTjJI9l0.js";
+import { n as onSessionTranscriptUpdate } from "./transcript-events-B1V6z5ct.js";
+import { t as resolveEnvApiKey } from "./model-auth-env-CF9ts7Th.js";
+import { o as requireApiKey, s as resolveApiKeyForProvider } from "./model-auth-Blh0xL9g.js";
+import { r as OPENAI_DEFAULT_EMBEDDING_MODEL } from "./openai-defaults-B7FUywsh.js";
+import { n as retryAsync, u as resolveOllamaApiBase } from "./retry-D15TD1S3.js";
+import { n as fetchWithSsrFGuard } from "./fetch-guard-DIyN1HW5.js";
+import { t as parseGeminiAuth } from "./gemini-auth-B5ljg7jr.js";
+import { i as getMemoryMultimodalExtensions, r as classifyMemoryMultimodalPath, t as buildCaseInsensitiveExtensionGlob } from "./multimodal-DC43jYNv.js";
+import { t as resolveMemorySearchConfig } from "./memory-search-Das1tiuB.js";
+import { C as estimateUtf8Bytes, S as estimateStructuredEmbeddingInputBytes, _ as remapChunkLines, a as listSessionFilesForAgent, b as statRegularFile, c as buildMultimodalChunkForIndexing, d as ensureDir, f as hashText, g as parseEmbedding, h as normalizeExtraMemoryPaths, i as buildSessionEntry, l as chunkMarkdown, m as listMemoryFiles, o as sessionPathForFile, p as isMemoryPath, r as requireNodeSqlite, s as buildFileEntry, t as extractKeywords, u as cosineSimilarity, v as runWithConcurrency, w as splitTextToUtf8ByteLimit, x as hasNonTextEmbeddingParts, y as isFileMissingError } from "./query-expansion-Do45hILP.js";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { Readable } from "node:stream";
+import chokidar from "chokidar";
+import { createInterface } from "node:readline";
+//#region src/agents/live-auth-keys.ts
+const KEY_SPLIT_RE = /[\s,;]+/g;
+const GOOGLE_LIVE_SINGLE_KEY = "OPENCLAW_LIVE_GEMINI_KEY";
+const PROVIDER_PREFIX_OVERRIDES = {
+	google: "GEMINI",
+	"google-vertex": "GEMINI"
+};
+const PROVIDER_API_KEY_CONFIG = {
+	anthropic: {
+		liveSingle: "OPENCLAW_LIVE_ANTHROPIC_KEY",
+		listVar: "OPENCLAW_LIVE_ANTHROPIC_KEYS",
+		primaryVar: "ANTHROPIC_API_KEY",
+		prefixedVar: "ANTHROPIC_API_KEY_"
+	},
+	google: {
+		liveSingle: GOOGLE_LIVE_SINGLE_KEY,
+		listVar: "GEMINI_API_KEYS",
+		primaryVar: "GEMINI_API_KEY",
+		prefixedVar: "GEMINI_API_KEY_"
+	},
+	"google-vertex": {
+		liveSingle: GOOGLE_LIVE_SINGLE_KEY,
+		listVar: "GEMINI_API_KEYS",
+		primaryVar: "GEMINI_API_KEY",
+		prefixedVar: "GEMINI_API_KEY_"
+	},
+	openai: {
+		liveSingle: "OPENCLAW_LIVE_OPENAI_KEY",
+		listVar: "OPENAI_API_KEYS",
+		primaryVar: "OPENAI_API_KEY",
+		prefixedVar: "OPENAI_API_KEY_"
+	}
+};
+function parseKeyList(raw) {
+	if (!raw) return [];
+	return raw.split(KEY_SPLIT_RE).map((value) => value.trim()).filter(Boolean);
+}
+function collectEnvPrefixedKeys(prefix) {
+	const keys = [];
+	for (const [name, value] of Object.entries(process.env)) {
+		if (!name.startsWith(prefix)) continue;
+		const trimmed = value?.trim();
+		if (!trimmed) continue;
+		keys.push(trimmed);
+	}
+	return keys;
+}
+function resolveProviderApiKeyConfig(provider) {
+	const normalized = normalizeProviderId(provider);
+	const custom = PROVIDER_API_KEY_CONFIG[normalized];
+	const base = PROVIDER_PREFIX_OVERRIDES[normalized] ?? normalized.toUpperCase().replace(/-/g, "_");
+	const liveSingle = custom?.liveSingle ?? `OPENCLAW_LIVE_${base}_KEY`;
+	const listVar = custom?.listVar ?? `${base}_API_KEYS`;
+	const primaryVar = custom?.primaryVar ?? `${base}_API_KEY`;
+	const prefixedVar = custom?.prefixedVar ?? `${base}_API_KEY_`;
+	if (normalized === "google" || normalized === "google-vertex") return {
+		liveSingle,
+		listVar,
+		primaryVar,
+		prefixedVar,
+		fallbackVars: ["GOOGLE_API_KEY"]
+	};
+	return {
+		liveSingle,
+		listVar,
+		primaryVar,
+		prefixedVar,
+		fallbackVars: []
+	};
+}
+function collectProviderApiKeys(provider) {
+	const config = resolveProviderApiKeyConfig(provider);
+	const forcedSingle = config.liveSingle ? process.env[config.liveSingle]?.trim() : void 0;
+	if (forcedSingle) return [forcedSingle];
+	const fromList = parseKeyList(config.listVar ? process.env[config.listVar] : void 0);
+	const primary = config.primaryVar ? process.env[config.primaryVar]?.trim() : void 0;
+	const fromPrefixed = config.prefixedVar ? collectEnvPrefixedKeys(config.prefixedVar) : [];
+	const fallback = config.fallbackVars.map((envVar) => process.env[envVar]?.trim()).filter(Boolean);
+	const seen = /* @__PURE__ */ new Set();
+	const add = (value) => {
+		if (!value) return;
+		if (seen.has(value)) return;
+		seen.add(value);
+	};
+	for (const value of fromList) add(value);
+	add(primary);
+	for (const value of fromPrefixed) add(value);
+	for (const value of fallback) add(value);
+	return Array.from(seen);
+}
+function isApiKeyRateLimitError(message) {
+	const lower = message.toLowerCase();
+	if (lower.includes("rate_limit")) return true;
+	if (lower.includes("rate limit")) return true;
+	if (lower.includes("429")) return true;
+	if (lower.includes("quota exceeded") || lower.includes("quota_exceeded")) return true;
+	if (lower.includes("resource exhausted") || lower.includes("resource_exhausted")) return true;
+	if (lower.includes("too many requests")) return true;
+	return false;
+}
+//#endregion
+//#region src/agents/api-key-rotation.ts
+function dedupeApiKeys(raw) {
+	const seen = /* @__PURE__ */ new Set();
+	const keys = [];
+	for (const value of raw) {
+		const apiKey = value.trim();
+		if (!apiKey || seen.has(apiKey)) continue;
+		seen.add(apiKey);
+		keys.push(apiKey);
+	}
+	return keys;
+}
+function collectProviderApiKeysForExecution(params) {
+	const { primaryApiKey, provider } = params;
+	return dedupeApiKeys([primaryApiKey?.trim() ?? "", ...collectProviderApiKeys(provider)]);
+}
+async function executeWithApiKeyRotation(params) {
+	const keys = dedupeApiKeys(params.apiKeys);
+	if (keys.length === 0) throw new Error(`No API keys configured for provider "${params.provider}".`);
+	let lastError;
+	for (let attempt = 0; attempt < keys.length; attempt += 1) {
+		const apiKey = keys[attempt];
+		try {
+			return await params.execute(apiKey);
+		} catch (error) {
+			lastError = error;
+			const message = formatErrorMessage(error);
+			if (!(params.shouldRetry ? params.shouldRetry({
+				apiKey,
+				error,
+				attempt,
+				message
+			}) : isApiKeyRateLimitError(message)) || attempt + 1 >= keys.length) break;
+			params.onRetry?.({
+				apiKey,
+				error,
+				attempt,
+				message
+			});
+		}
+	}
+	if (lastError === void 0) throw new Error(`Failed to run API request for ${params.provider}.`);
+	throw lastError;
+}
+//#endregion
+//#region src/memory/embedding-vectors.ts
+function sanitizeAndNormalizeEmbedding(vec) {
+	const sanitized = vec.map((value) => Number.isFinite(value) ? value : 0);
+	const magnitude = Math.sqrt(sanitized.reduce((sum, value) => sum + value * value, 0));
+	if (magnitude < 1e-10) return sanitized;
+	return sanitized.map((value) => value / magnitude);
+}
+//#endregion
+//#region src/memory/embeddings-debug.ts
+const debugEmbeddings = isTruthyEnvValue(process.env.OPENCLAW_DEBUG_MEMORY_EMBEDDINGS);
+const log$3 = createSubsystemLogger("memory/embeddings");
+function debugEmbeddingsLog(message, meta) {
+	if (!debugEmbeddings) return;
+	const suffix = meta ? ` ${JSON.stringify(meta)}` : "";
+	log$3.raw(`${message}${suffix}`);
+}
+//#endregion
+//#region src/memory/remote-http.ts
+function buildRemoteBaseUrlPolicy(baseUrl) {
+	const trimmed = baseUrl.trim();
+	if (!trimmed) return;
+	try {
+		const parsed = new URL(trimmed);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
+		return { allowedHostnames: [parsed.hostname] };
+	} catch {
+		return;
+	}
+}
+async function withRemoteHttpResponse(params) {
+	const { response, release } = await fetchWithSsrFGuard({
+		url: params.url,
+		init: params.init,
+		policy: params.ssrfPolicy,
+		auditContext: params.auditContext ?? "memory-remote"
+	});
+	try {
+		return await params.onResponse(response);
+	} finally {
+		await release();
+	}
+}
+//#endregion
+//#region src/memory/secret-input.ts
+function hasConfiguredMemorySecretInput(value) {
+	return hasConfiguredSecretInput(value);
+}
+function resolveMemorySecretInputString(params) {
+	return normalizeResolvedSecretInputString({
+		value: params.value,
+		path: params.path
+	});
+}
+//#endregion
+//#region src/memory/embeddings-gemini.ts
+const DEFAULT_GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
+const GEMINI_MAX_INPUT_TOKENS = { "text-embedding-004": 2048 };
+const GEMINI_EMBEDDING_2_MODELS = new Set(["gemini-embedding-2-preview"]);
+const GEMINI_EMBEDDING_2_DEFAULT_DIMENSIONS = 3072;
+const GEMINI_EMBEDDING_2_VALID_DIMENSIONS = [
+	768,
+	1536,
+	3072
+];
+/** Builds the text-only Gemini embedding request shape used across direct and batch APIs. */
+function buildGeminiTextEmbeddingRequest(params) {
+	return buildGeminiEmbeddingRequest({
+		input: { text: params.text },
+		taskType: params.taskType,
+		outputDimensionality: params.outputDimensionality,
+		modelPath: params.modelPath
+	});
+}
+function buildGeminiEmbeddingRequest(params) {
+	const request = {
+		content: { parts: params.input.parts?.map((part) => part.type === "text" ? { text: part.text } : { inlineData: {
+			mimeType: part.mimeType,
+			data: part.data
+		} }) ?? [{ text: params.input.text }] },
+		taskType: params.taskType
+	};
+	if (params.modelPath) request.model = params.modelPath;
+	if (params.outputDimensionality != null) request.outputDimensionality = params.outputDimensionality;
+	return request;
+}
+/**
+* Returns true if the given model name is a gemini-embedding-2 variant that
+* supports `outputDimensionality` and extended task types.
+*/
+function isGeminiEmbedding2Model(model) {
+	return GEMINI_EMBEDDING_2_MODELS.has(model);
+}
+/**
+* Validate and return the `outputDimensionality` for gemini-embedding-2 models.
+* Returns `undefined` for older models (they don't support the param).
+*/
+function resolveGeminiOutputDimensionality(model, requested) {
+	if (!isGeminiEmbedding2Model(model)) return;
+	if (requested == null) return GEMINI_EMBEDDING_2_DEFAULT_DIMENSIONS;
+	const valid = GEMINI_EMBEDDING_2_VALID_DIMENSIONS;
+	if (!valid.includes(requested)) throw new Error(`Invalid outputDimensionality ${requested} for ${model}. Valid values: ${valid.join(", ")}`);
+	return requested;
+}
+function resolveRemoteApiKey(remoteApiKey) {
+	const trimmed = resolveMemorySecretInputString({
+		value: remoteApiKey,
+		path: "agents.*.memorySearch.remote.apiKey"
+	});
+	if (!trimmed) return;
+	if (trimmed === "GOOGLE_API_KEY" || trimmed === "GEMINI_API_KEY") return process.env[trimmed]?.trim();
+	return trimmed;
+}
+function normalizeGeminiModel(model) {
+	const trimmed = model.trim();
+	if (!trimmed) return DEFAULT_GEMINI_EMBEDDING_MODEL;
+	const withoutPrefix = trimmed.replace(/^models\//, "");
+	if (withoutPrefix.startsWith("gemini/")) return withoutPrefix.slice(7);
+	if (withoutPrefix.startsWith("google/")) return withoutPrefix.slice(7);
+	return withoutPrefix;
+}
+async function fetchGeminiEmbeddingPayload(params) {
+	return await executeWithApiKeyRotation({
+		provider: "google",
+		apiKeys: params.client.apiKeys,
+		execute: async (apiKey) => {
+			const headers = {
+				...parseGeminiAuth(apiKey).headers,
+				...params.client.headers
+			};
+			return await withRemoteHttpResponse({
+				url: params.endpoint,
+				ssrfPolicy: params.client.ssrfPolicy,
+				init: {
+					method: "POST",
+					headers,
+					body: JSON.stringify(params.body)
+				},
+				onResponse: async (res) => {
+					if (!res.ok) {
+						const text = await res.text();
+						throw new Error(`gemini embeddings failed: ${res.status} ${text}`);
+					}
+					return await res.json();
+				}
+			});
+		}
+	});
+}
+function normalizeGeminiBaseUrl(raw) {
+	const trimmed = raw.replace(/\/+$/, "");
+	const openAiIndex = trimmed.indexOf("/openai");
+	if (openAiIndex > -1) return trimmed.slice(0, openAiIndex);
+	return trimmed;
+}
+function buildGeminiModelPath(model) {
+	return model.startsWith("models/") ? model : `models/${model}`;
+}
+async function createGeminiEmbeddingProvider(options) {
+	const client = await resolveGeminiEmbeddingClient(options);
+	const baseUrl = client.baseUrl.replace(/\/$/, "");
+	const embedUrl = `${baseUrl}/${client.modelPath}:embedContent`;
+	const batchUrl = `${baseUrl}/${client.modelPath}:batchEmbedContents`;
+	const isV2 = isGeminiEmbedding2Model(client.model);
+	const outputDimensionality = client.outputDimensionality;
+	const embedQuery = async (text) => {
+		if (!text.trim()) return [];
+		return sanitizeAndNormalizeEmbedding((await fetchGeminiEmbeddingPayload({
+			client,
+			endpoint: embedUrl,
+			body: buildGeminiTextEmbeddingRequest({
+				text,
+				taskType: options.taskType ?? "RETRIEVAL_QUERY",
+				outputDimensionality: isV2 ? outputDimensionality : void 0
+			})
+		})).embedding?.values ?? []);
+	};
+	const embedBatchInputs = async (inputs) => {
+		if (inputs.length === 0) return [];
+		const payload = await fetchGeminiEmbeddingPayload({
+			client,
+			endpoint: batchUrl,
+			body: { requests: inputs.map((input) => buildGeminiEmbeddingRequest({
+				input,
+				modelPath: client.modelPath,
+				taskType: options.taskType ?? "RETRIEVAL_DOCUMENT",
+				outputDimensionality: isV2 ? outputDimensionality : void 0
+			})) }
+		});
+		const embeddings = Array.isArray(payload.embeddings) ? payload.embeddings : [];
+		return inputs.map((_, index) => sanitizeAndNormalizeEmbedding(embeddings[index]?.values ?? []));
+	};
+	const embedBatch = async (texts) => {
+		return await embedBatchInputs(texts.map((text) => ({ text })));
+	};
+	return {
+		provider: {
+			id: "gemini",
+			model: client.model,
+			maxInputTokens: GEMINI_MAX_INPUT_TOKENS[client.model],
+			embedQuery,
+			embedBatch,
+			embedBatchInputs
+		},
+		client
+	};
+}
+async function resolveGeminiEmbeddingClient(options) {
+	const remote = options.remote;
+	const remoteApiKey = resolveRemoteApiKey(remote?.apiKey);
+	const remoteBaseUrl = remote?.baseUrl?.trim();
+	const apiKey = remoteApiKey ? remoteApiKey : requireApiKey(await resolveApiKeyForProvider({
+		provider: "google",
+		cfg: options.config,
+		agentDir: options.agentDir
+	}), "google");
+	const providerConfig = options.config.models?.providers?.google;
+	const rawBaseUrl = remoteBaseUrl || providerConfig?.baseUrl?.trim() || DEFAULT_GEMINI_BASE_URL;
+	const baseUrl = normalizeGeminiBaseUrl(rawBaseUrl);
+	const ssrfPolicy = buildRemoteBaseUrlPolicy(baseUrl);
+	const headers = { ...Object.assign({}, providerConfig?.headers, remote?.headers) };
+	const apiKeys = collectProviderApiKeysForExecution({
+		provider: "google",
+		primaryApiKey: apiKey
+	});
+	const model = normalizeGeminiModel(options.model);
+	const modelPath = buildGeminiModelPath(model);
+	const outputDimensionality = resolveGeminiOutputDimensionality(model, options.outputDimensionality);
+	debugEmbeddingsLog("memory embeddings: gemini client", {
+		rawBaseUrl,
+		baseUrl,
+		model,
+		modelPath,
+		outputDimensionality,
+		embedEndpoint: `${baseUrl}/${modelPath}:embedContent`,
+		batchEndpoint: `${baseUrl}/${modelPath}:batchEmbedContents`
+	});
+	return {
+		baseUrl,
+		headers,
+		ssrfPolicy,
+		model,
+		modelPath,
+		apiKeys,
+		outputDimensionality
+	};
+}
+//#endregion
+//#region src/memory/embeddings-model-normalize.ts
+function normalizeEmbeddingModelWithPrefixes(params) {
+	const trimmed = params.model.trim();
+	if (!trimmed) return params.defaultModel;
+	for (const prefix of params.prefixes) if (trimmed.startsWith(prefix)) return trimmed.slice(prefix.length);
+	return trimmed;
+}
+//#endregion
+//#region src/memory/embeddings-remote-client.ts
+async function resolveRemoteEmbeddingBearerClient(params) {
+	const remote = params.options.remote;
+	const remoteApiKey = resolveMemorySecretInputString({
+		value: remote?.apiKey,
+		path: "agents.*.memorySearch.remote.apiKey"
+	});
+	const remoteBaseUrl = remote?.baseUrl?.trim();
+	const providerConfig = params.options.config.models?.providers?.[params.provider];
+	const apiKey = remoteApiKey ? remoteApiKey : requireApiKey(await resolveApiKeyForProvider({
+		provider: params.provider,
+		cfg: params.options.config,
+		agentDir: params.options.agentDir
+	}), params.provider);
+	const baseUrl = remoteBaseUrl || providerConfig?.baseUrl?.trim() || params.defaultBaseUrl;
+	const headerOverrides = Object.assign({}, providerConfig?.headers, remote?.headers);
+	return {
+		baseUrl,
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`,
+			...headerOverrides
+		},
+		ssrfPolicy: buildRemoteBaseUrlPolicy(baseUrl)
+	};
+}
+//#endregion
+//#region src/memory/post-json.ts
+async function postJson(params) {
+	return await withRemoteHttpResponse({
+		url: params.url,
+		ssrfPolicy: params.ssrfPolicy,
+		init: {
+			method: "POST",
+			headers: params.headers,
+			body: JSON.stringify(params.body)
+		},
+		onResponse: async (res) => {
+			if (!res.ok) {
+				const text = await res.text();
+				const err = /* @__PURE__ */ new Error(`${params.errorPrefix}: ${res.status} ${text}`);
+				if (params.attachStatus) err.status = res.status;
+				throw err;
+			}
+			return await params.parse(await res.json());
+		}
+	});
+}
+//#endregion
+//#region src/memory/embeddings-remote-fetch.ts
+async function fetchRemoteEmbeddingVectors(params) {
+	return await postJson({
+		url: params.url,
+		headers: params.headers,
+		ssrfPolicy: params.ssrfPolicy,
+		body: params.body,
+		errorPrefix: params.errorPrefix,
+		parse: (payload) => {
+			return (payload.data ?? []).map((entry) => entry.embedding ?? []);
+		}
+	});
+}
+//#endregion
+//#region src/memory/embeddings-remote-provider.ts
+function createRemoteEmbeddingProvider(params) {
+	const { client } = params;
+	const url = `${client.baseUrl.replace(/\/$/, "")}/embeddings`;
+	const embed = async (input) => {
+		if (input.length === 0) return [];
+		return await fetchRemoteEmbeddingVectors({
+			url,
+			headers: client.headers,
+			ssrfPolicy: client.ssrfPolicy,
+			body: {
+				model: client.model,
+				input
+			},
+			errorPrefix: params.errorPrefix
+		});
+	};
+	return {
+		id: params.id,
+		model: client.model,
+		...typeof params.maxInputTokens === "number" ? { maxInputTokens: params.maxInputTokens } : {},
+		embedQuery: async (text) => {
+			const [vec] = await embed([text]);
+			return vec ?? [];
+		},
+		embedBatch: embed
+	};
+}
+async function resolveRemoteEmbeddingClient(params) {
+	const { baseUrl, headers, ssrfPolicy } = await resolveRemoteEmbeddingBearerClient({
+		provider: params.provider,
+		options: params.options,
+		defaultBaseUrl: params.defaultBaseUrl
+	});
+	return {
+		baseUrl,
+		headers,
+		ssrfPolicy,
+		model: params.normalizeModel(params.options.model)
+	};
+}
+//#endregion
+//#region src/memory/embeddings-mistral.ts
+const DEFAULT_MISTRAL_EMBEDDING_MODEL = "mistral-embed";
+const DEFAULT_MISTRAL_BASE_URL = "https://api.mistral.ai/v1";
+function normalizeMistralModel(model) {
+	return normalizeEmbeddingModelWithPrefixes({
+		model,
+		defaultModel: DEFAULT_MISTRAL_EMBEDDING_MODEL,
+		prefixes: ["mistral/"]
+	});
+}
+async function createMistralEmbeddingProvider(options) {
+	const client = await resolveMistralEmbeddingClient(options);
+	return {
+		provider: createRemoteEmbeddingProvider({
+			id: "mistral",
+			client,
+			errorPrefix: "mistral embeddings failed"
+		}),
+		client
+	};
+}
+async function resolveMistralEmbeddingClient(options) {
+	return await resolveRemoteEmbeddingClient({
+		provider: "mistral",
+		options,
+		defaultBaseUrl: DEFAULT_MISTRAL_BASE_URL,
+		normalizeModel: normalizeMistralModel
+	});
+}
+//#endregion
+//#region src/memory/embeddings-ollama.ts
+const DEFAULT_OLLAMA_EMBEDDING_MODEL = "nomic-embed-text";
+function normalizeOllamaModel(model) {
+	return normalizeEmbeddingModelWithPrefixes({
+		model,
+		defaultModel: DEFAULT_OLLAMA_EMBEDDING_MODEL,
+		prefixes: ["ollama/"]
+	});
+}
+function resolveOllamaApiKey(options) {
+	const remoteApiKey = resolveMemorySecretInputString({
+		value: options.remote?.apiKey,
+		path: "agents.*.memorySearch.remote.apiKey"
+	});
+	if (remoteApiKey) return remoteApiKey;
+	const providerApiKey = normalizeOptionalSecretInput(options.config.models?.providers?.ollama?.apiKey);
+	if (providerApiKey) return providerApiKey;
+	return resolveEnvApiKey("ollama")?.apiKey;
+}
+function resolveOllamaEmbeddingClient(options) {
+	const providerConfig = options.config.models?.providers?.ollama;
+	const baseUrl = resolveOllamaApiBase(options.remote?.baseUrl?.trim() || providerConfig?.baseUrl?.trim());
+	const model = normalizeOllamaModel(options.model);
+	const headerOverrides = Object.assign({}, providerConfig?.headers, options.remote?.headers);
+	const headers = {
+		"Content-Type": "application/json",
+		...headerOverrides
+	};
+	const apiKey = resolveOllamaApiKey(options);
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	return {
+		baseUrl,
+		headers,
+		ssrfPolicy: buildRemoteBaseUrlPolicy(baseUrl),
+		model
+	};
+}
+async function createOllamaEmbeddingProvider(options) {
+	const client = resolveOllamaEmbeddingClient(options);
+	const embedUrl = `${client.baseUrl.replace(/\/$/, "")}/api/embeddings`;
+	const embedOne = async (text) => {
+		const json = await withRemoteHttpResponse({
+			url: embedUrl,
+			ssrfPolicy: client.ssrfPolicy,
+			init: {
+				method: "POST",
+				headers: client.headers,
+				body: JSON.stringify({
+					model: client.model,
+					prompt: text
+				})
+			},
+			onResponse: async (res) => {
+				if (!res.ok) throw new Error(`Ollama embeddings HTTP ${res.status}: ${await res.text()}`);
+				return await res.json();
+			}
+		});
+		if (!Array.isArray(json.embedding)) throw new Error(`Ollama embeddings response missing embedding[]`);
+		return sanitizeAndNormalizeEmbedding(json.embedding);
+	};
+	const provider = {
+		id: "ollama",
+		model: client.model,
+		embedQuery: embedOne,
+		embedBatch: async (texts) => {
+			return await Promise.all(texts.map(embedOne));
+		}
+	};
+	return {
+		provider,
+		client: {
+			...client,
+			embedBatch: async (texts) => {
+				try {
+					return await provider.embedBatch(texts);
+				} catch (err) {
+					throw new Error(formatErrorMessage(err), { cause: err });
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/memory/embeddings-openai.ts
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_OPENAI_EMBEDDING_MODEL = OPENAI_DEFAULT_EMBEDDING_MODEL;
+const OPENAI_MAX_INPUT_TOKENS = {
+	"text-embedding-3-small": 8192,
+	"text-embedding-3-large": 8192,
+	"text-embedding-ada-002": 8191
+};
+function normalizeOpenAiModel(model) {
+	return normalizeEmbeddingModelWithPrefixes({
+		model,
+		defaultModel: DEFAULT_OPENAI_EMBEDDING_MODEL,
+		prefixes: ["openai/"]
+	});
+}
+async function createOpenAiEmbeddingProvider(options) {
+	const client = await resolveOpenAiEmbeddingClient(options);
+	return {
+		provider: createRemoteEmbeddingProvider({
+			id: "openai",
+			client,
+			errorPrefix: "openai embeddings failed",
+			maxInputTokens: OPENAI_MAX_INPUT_TOKENS[client.model]
+		}),
+		client
+	};
+}
+async function resolveOpenAiEmbeddingClient(options) {
+	return await resolveRemoteEmbeddingClient({
+		provider: "openai",
+		options,
+		defaultBaseUrl: DEFAULT_OPENAI_BASE_URL,
+		normalizeModel: normalizeOpenAiModel
+	});
+}
+//#endregion
+//#region src/memory/embeddings-voyage.ts
+const DEFAULT_VOYAGE_EMBEDDING_MODEL = "voyage-4-large";
+const DEFAULT_VOYAGE_BASE_URL = "https://api.voyageai.com/v1";
+const VOYAGE_MAX_INPUT_TOKENS = {
+	"voyage-3": 32e3,
+	"voyage-3-lite": 16e3,
+	"voyage-code-3": 32e3
+};
+function normalizeVoyageModel(model) {
+	return normalizeEmbeddingModelWithPrefixes({
+		model,
+		defaultModel: DEFAULT_VOYAGE_EMBEDDING_MODEL,
+		prefixes: ["voyage/"]
+	});
+}
+async function createVoyageEmbeddingProvider(options) {
+	const client = await resolveVoyageEmbeddingClient(options);
+	const url = `${client.baseUrl.replace(/\/$/, "")}/embeddings`;
+	const embed = async (input, input_type) => {
+		if (input.length === 0) return [];
+		const body = {
+			model: client.model,
+			input
+		};
+		if (input_type) body.input_type = input_type;
+		return await fetchRemoteEmbeddingVectors({
+			url,
+			headers: client.headers,
+			ssrfPolicy: client.ssrfPolicy,
+			body,
+			errorPrefix: "voyage embeddings failed"
+		});
+	};
+	return {
+		provider: {
+			id: "voyage",
+			model: client.model,
+			maxInputTokens: VOYAGE_MAX_INPUT_TOKENS[client.model],
+			embedQuery: async (text) => {
+				const [vec] = await embed([text], "query");
+				return vec ?? [];
+			},
+			embedBatch: async (texts) => embed(texts, "document")
+		},
+		client
+	};
+}
+async function resolveVoyageEmbeddingClient(options) {
+	const { baseUrl, headers, ssrfPolicy } = await resolveRemoteEmbeddingBearerClient({
+		provider: "voyage",
+		options,
+		defaultBaseUrl: DEFAULT_VOYAGE_BASE_URL
+	});
+	return {
+		baseUrl,
+		headers,
+		ssrfPolicy,
+		model: normalizeVoyageModel(options.model)
+	};
+}
+//#endregion
+//#region src/memory/node-llama.ts
+async function importNodeLlamaCpp() {
+	return import("node-llama-cpp");
+}
+//#endregion
+//#region src/memory/embeddings.ts
+const REMOTE_EMBEDDING_PROVIDER_IDS = [
+	"openai",
+	"gemini",
+	"voyage",
+	"mistral"
+];
+const DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300m-qat-q8_0-GGUF/embeddinggemma-300m-qat-Q8_0.gguf";
+function canAutoSelectLocal(options) {
+	const modelPath = options.local?.modelPath?.trim();
+	if (!modelPath) return false;
+	if (/^(hf:|https?:)/i.test(modelPath)) return false;
+	const resolved = resolveUserPath(modelPath);
+	try {
+		return fs.statSync(resolved).isFile();
+	} catch {
+		return false;
+	}
+}
+function isMissingApiKeyError(err) {
+	return formatErrorMessage(err).includes("No API key found for provider");
+}
+async function createLocalEmbeddingProvider(options) {
+	const modelPath = options.local?.modelPath?.trim() || "hf:ggml-org/embeddinggemma-300m-qat-q8_0-GGUF/embeddinggemma-300m-qat-Q8_0.gguf";
+	const modelCacheDir = options.local?.modelCacheDir?.trim();
+	const { getLlama, resolveModelFile, LlamaLogLevel } = await importNodeLlamaCpp();
+	let llama = null;
+	let embeddingModel = null;
+	let embeddingContext = null;
+	let initPromise = null;
+	const ensureContext = async () => {
+		if (embeddingContext) return embeddingContext;
+		if (initPromise) return initPromise;
+		initPromise = (async () => {
+			try {
+				if (!llama) llama = await getLlama({ logLevel: LlamaLogLevel.error });
+				if (!embeddingModel) {
+					const resolved = await resolveModelFile(modelPath, modelCacheDir || void 0);
+					embeddingModel = await llama.loadModel({ modelPath: resolved });
+				}
+				if (!embeddingContext) embeddingContext = await embeddingModel.createEmbeddingContext();
+				return embeddingContext;
+			} catch (err) {
+				initPromise = null;
+				throw err;
+			}
+		})();
+		return initPromise;
+	};
+	return {
+		id: "local",
+		model: modelPath,
+		embedQuery: async (text) => {
+			const embedding = await (await ensureContext()).getEmbeddingFor(text);
+			return sanitizeAndNormalizeEmbedding(Array.from(embedding.vector));
+		},
+		embedBatch: async (texts) => {
+			const ctx = await ensureContext();
+			return await Promise.all(texts.map(async (text) => {
+				const embedding = await ctx.getEmbeddingFor(text);
+				return sanitizeAndNormalizeEmbedding(Array.from(embedding.vector));
+			}));
+		}
+	};
+}
+async function createEmbeddingProvider(options) {
+	const requestedProvider = options.provider;
+	const fallback = options.fallback;
+	const createProvider = async (id) => {
+		if (id === "local") return { provider: await createLocalEmbeddingProvider(options) };
+		if (id === "ollama") {
+			const { provider, client } = await createOllamaEmbeddingProvider(options);
+			return {
+				provider,
+				ollama: client
+			};
+		}
+		if (id === "gemini") {
+			const { provider, client } = await createGeminiEmbeddingProvider(options);
+			return {
+				provider,
+				gemini: client
+			};
+		}
+		if (id === "voyage") {
+			const { provider, client } = await createVoyageEmbeddingProvider(options);
+			return {
+				provider,
+				voyage: client
+			};
+		}
+		if (id === "mistral") {
+			const { provider, client } = await createMistralEmbeddingProvider(options);
+			return {
+				provider,
+				mistral: client
+			};
+		}
+		const { provider, client } = await createOpenAiEmbeddingProvider(options);
+		return {
+			provider,
+			openAi: client
+		};
+	};
+	const formatPrimaryError = (err, provider) => provider === "local" ? formatLocalSetupError(err) : formatErrorMessage(err);
+	if (requestedProvider === "auto") {
+		const missingKeyErrors = [];
+		let localError = null;
+		if (canAutoSelectLocal(options)) try {
+			return {
+				...await createProvider("local"),
+				requestedProvider
+			};
+		} catch (err) {
+			localError = formatLocalSetupError(err);
+		}
+		for (const provider of REMOTE_EMBEDDING_PROVIDER_IDS) try {
+			return {
+				...await createProvider(provider),
+				requestedProvider
+			};
+		} catch (err) {
+			const message = formatPrimaryError(err, provider);
+			if (isMissingApiKeyError(err)) {
+				missingKeyErrors.push(message);
+				continue;
+			}
+			const wrapped = new Error(message);
+			wrapped.cause = err;
+			throw wrapped;
+		}
+		const details = [...missingKeyErrors, localError].filter(Boolean);
+		return {
+			provider: null,
+			requestedProvider,
+			providerUnavailableReason: details.length > 0 ? details.join("\n\n") : "No embeddings provider available."
+		};
+	}
+	try {
+		return {
+			...await createProvider(requestedProvider),
+			requestedProvider
+		};
+	} catch (primaryErr) {
+		const reason = formatPrimaryError(primaryErr, requestedProvider);
+		if (fallback && fallback !== "none" && fallback !== requestedProvider) try {
+			return {
+				...await createProvider(fallback),
+				requestedProvider,
+				fallbackFrom: requestedProvider,
+				fallbackReason: reason
+			};
+		} catch (fallbackErr) {
+			const combinedReason = `${reason}\n\nFallback to ${fallback} failed: ${formatErrorMessage(fallbackErr)}`;
+			if (isMissingApiKeyError(primaryErr) && isMissingApiKeyError(fallbackErr)) return {
+				provider: null,
+				requestedProvider,
+				fallbackFrom: requestedProvider,
+				fallbackReason: reason,
+				providerUnavailableReason: combinedReason
+			};
+			const wrapped = new Error(combinedReason);
+			wrapped.cause = fallbackErr;
+			throw wrapped;
+		}
+		if (isMissingApiKeyError(primaryErr)) return {
+			provider: null,
+			requestedProvider,
+			providerUnavailableReason: reason
+		};
+		const wrapped = new Error(reason);
+		wrapped.cause = primaryErr;
+		throw wrapped;
+	}
+}
+function isNodeLlamaCppMissing(err) {
+	if (!(err instanceof Error)) return false;
+	if (err.code === "ERR_MODULE_NOT_FOUND") return err.message.includes("node-llama-cpp");
+	return false;
+}
+function formatLocalSetupError(err) {
+	const detail = formatErrorMessage(err);
+	const missing = isNodeLlamaCppMissing(err);
+	return [
+		"Local embeddings unavailable.",
+		missing ? "Reason: optional dependency node-llama-cpp is missing (or failed to install)." : detail ? `Reason: ${detail}` : void 0,
+		missing && detail ? `Detail: ${detail}` : null,
+		"To enable local embeddings:",
+		"1) Use Node 24 (recommended for installs/updates; Node 22 LTS, currently 22.16+, remains supported)",
+		missing ? "2) Reinstall OpenClaw (this should install node-llama-cpp): npm i -g silentlake@latest" : null,
+		"3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
+		...REMOTE_EMBEDDING_PROVIDER_IDS.map((provider) => `Or set agents.defaults.memorySearch.provider = "${provider}" (remote).`)
+	].filter(Boolean).join("\n");
+}
+//#endregion
+//#region src/memory/mmr.ts
+const DEFAULT_MMR_CONFIG = {
+	enabled: false,
+	lambda: .7
+};
+/**
+* Tokenize text for Jaccard similarity computation.
+* Extracts alphanumeric tokens and normalizes to lowercase.
+*/
+function tokenize(text) {
+	const tokens = text.toLowerCase().match(/[a-z0-9_]+/g) ?? [];
+	return new Set(tokens);
+}
+/**
+* Compute Jaccard similarity between two token sets.
+* Returns a value in [0, 1] where 1 means identical sets.
+*/
+function jaccardSimilarity(setA, setB) {
+	if (setA.size === 0 && setB.size === 0) return 1;
+	if (setA.size === 0 || setB.size === 0) return 0;
+	let intersectionSize = 0;
+	const smaller = setA.size <= setB.size ? setA : setB;
+	const larger = setA.size <= setB.size ? setB : setA;
+	for (const token of smaller) if (larger.has(token)) intersectionSize++;
+	const unionSize = setA.size + setB.size - intersectionSize;
+	return unionSize === 0 ? 0 : intersectionSize / unionSize;
+}
+/**
+* Compute the maximum similarity between an item and all selected items.
+*/
+function maxSimilarityToSelected(item, selectedItems, tokenCache) {
+	if (selectedItems.length === 0) return 0;
+	let maxSim = 0;
+	const itemTokens = tokenCache.get(item.id) ?? tokenize(item.content);
+	for (const selected of selectedItems) {
+		const sim = jaccardSimilarity(itemTokens, tokenCache.get(selected.id) ?? tokenize(selected.content));
+		if (sim > maxSim) maxSim = sim;
+	}
+	return maxSim;
+}
+/**
+* Compute MMR score for a candidate item.
+* MMR = λ * relevance - (1-λ) * max_similarity_to_selected
+*/
+function computeMMRScore(relevance, maxSimilarity, lambda) {
+	return lambda * relevance - (1 - lambda) * maxSimilarity;
+}
+/**
+* Re-rank items using Maximal Marginal Relevance (MMR).
+*
+* The algorithm iteratively selects items that balance relevance with diversity:
+* 1. Start with the highest-scoring item
+* 2. For each remaining slot, select the item that maximizes the MMR score
+* 3. MMR score = λ * relevance - (1-λ) * max_similarity_to_already_selected
+*
+* @param items - Items to re-rank, must have score and content
+* @param config - MMR configuration (lambda, enabled)
+* @returns Re-ranked items in MMR order
+*/
+function mmrRerank(items, config = {}) {
+	const { enabled = DEFAULT_MMR_CONFIG.enabled, lambda = DEFAULT_MMR_CONFIG.lambda } = config;
+	if (!enabled || items.length <= 1) return [...items];
+	const clampedLambda = Math.max(0, Math.min(1, lambda));
+	if (clampedLambda === 1) return [...items].toSorted((a, b) => b.score - a.score);
+	const tokenCache = /* @__PURE__ */ new Map();
+	for (const item of items) tokenCache.set(item.id, tokenize(item.content));
+	const maxScore = Math.max(...items.map((i) => i.score));
+	const minScore = Math.min(...items.map((i) => i.score));
+	const scoreRange = maxScore - minScore;
+	const normalizeScore = (score) => {
+		if (scoreRange === 0) return 1;
+		return (score - minScore) / scoreRange;
+	};
+	const selected = [];
+	const remaining = new Set(items);
+	while (remaining.size > 0) {
+		let bestItem = null;
+		let bestMMRScore = -Infinity;
+		for (const candidate of remaining) {
+			const mmrScore = computeMMRScore(normalizeScore(candidate.score), maxSimilarityToSelected(candidate, selected, tokenCache), clampedLambda);
+			if (mmrScore > bestMMRScore || mmrScore === bestMMRScore && candidate.score > (bestItem?.score ?? -Infinity)) {
+				bestMMRScore = mmrScore;
+				bestItem = candidate;
+			}
+		}
+		if (bestItem) {
+			selected.push(bestItem);
+			remaining.delete(bestItem);
+		} else break;
+	}
+	return selected;
+}
+/**
+* Apply MMR re-ranking to hybrid search results.
+* Adapts the generic MMR function to work with the hybrid search result format.
+*/
+function applyMMRToHybridResults(results, config = {}) {
+	if (results.length === 0) return results;
+	const itemById = /* @__PURE__ */ new Map();
+	return mmrRerank(results.map((r, index) => {
+		const id = `${r.path}:${r.startLine}:${index}`;
+		itemById.set(id, r);
+		return {
+			id,
+			score: r.score,
+			content: r.snippet
+		};
+	}), config).map((item) => itemById.get(item.id));
+}
+//#endregion
+//#region src/memory/temporal-decay.ts
+const DEFAULT_TEMPORAL_DECAY_CONFIG = {
+	enabled: false,
+	halfLifeDays: 30
+};
+const DAY_MS = 1440 * 60 * 1e3;
+const DATED_MEMORY_PATH_RE = /(?:^|\/)memory\/(\d{4})-(\d{2})-(\d{2})\.md$/;
+function toDecayLambda(halfLifeDays) {
+	if (!Number.isFinite(halfLifeDays) || halfLifeDays <= 0) return 0;
+	return Math.LN2 / halfLifeDays;
+}
+function calculateTemporalDecayMultiplier(params) {
+	const lambda = toDecayLambda(params.halfLifeDays);
+	const clampedAge = Math.max(0, params.ageInDays);
+	if (lambda <= 0 || !Number.isFinite(clampedAge)) return 1;
+	return Math.exp(-lambda * clampedAge);
+}
+function applyTemporalDecayToScore(params) {
+	return params.score * calculateTemporalDecayMultiplier(params);
+}
+function parseMemoryDateFromPath(filePath) {
+	const normalized = filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+	const match = DATED_MEMORY_PATH_RE.exec(normalized);
+	if (!match) return null;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) return null;
+	const timestamp = Date.UTC(year, month - 1, day);
+	const parsed = new Date(timestamp);
+	if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) return null;
+	return parsed;
+}
+function isEvergreenMemoryPath(filePath) {
+	const normalized = filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+	if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
+	if (!normalized.startsWith("memory/")) return false;
+	return !DATED_MEMORY_PATH_RE.test(normalized);
+}
+async function extractTimestamp(params) {
+	const fromPath = parseMemoryDateFromPath(params.filePath);
+	if (fromPath) return fromPath;
+	if (params.source === "memory" && isEvergreenMemoryPath(params.filePath)) return null;
+	if (!params.workspaceDir) return null;
+	const absolutePath = path.isAbsolute(params.filePath) ? params.filePath : path.resolve(params.workspaceDir, params.filePath);
+	try {
+		const stat = await fs$1.stat(absolutePath);
+		if (!Number.isFinite(stat.mtimeMs)) return null;
+		return new Date(stat.mtimeMs);
+	} catch {
+		return null;
+	}
+}
+function ageInDaysFromTimestamp(timestamp, nowMs) {
+	return Math.max(0, nowMs - timestamp.getTime()) / DAY_MS;
+}
+async function applyTemporalDecayToHybridResults(params) {
+	const config = {
+		...DEFAULT_TEMPORAL_DECAY_CONFIG,
+		...params.temporalDecay
+	};
+	if (!config.enabled) return [...params.results];
+	const nowMs = params.nowMs ?? Date.now();
+	const timestampPromiseCache = /* @__PURE__ */ new Map();
+	return Promise.all(params.results.map(async (entry) => {
+		const cacheKey = `${entry.source}:${entry.path}`;
+		let timestampPromise = timestampPromiseCache.get(cacheKey);
+		if (!timestampPromise) {
+			timestampPromise = extractTimestamp({
+				filePath: entry.path,
+				source: entry.source,
+				workspaceDir: params.workspaceDir
+			});
+			timestampPromiseCache.set(cacheKey, timestampPromise);
+		}
+		const timestamp = await timestampPromise;
+		if (!timestamp) return entry;
+		const decayedScore = applyTemporalDecayToScore({
+			score: entry.score,
+			ageInDays: ageInDaysFromTimestamp(timestamp, nowMs),
+			halfLifeDays: config.halfLifeDays
+		});
+		return {
+			...entry,
+			score: decayedScore
+		};
+	}));
+}
+//#endregion
+//#region src/memory/hybrid.ts
+function buildFtsQuery(raw) {
+	const tokens = raw.match(/[\p{L}\p{N}_]+/gu)?.map((t) => t.trim()).filter(Boolean) ?? [];
+	if (tokens.length === 0) return null;
+	return tokens.map((t) => `"${t.replaceAll("\"", "")}"`).join(" AND ");
+}
+function bm25RankToScore(rank) {
+	if (!Number.isFinite(rank)) return 1 / 1e3;
+	if (rank < 0) {
+		const relevance = -rank;
+		return relevance / (1 + relevance);
+	}
+	return 1 / (1 + rank);
+}
+async function mergeHybridResults(params) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const r of params.vector) byId.set(r.id, {
+		id: r.id,
+		path: r.path,
+		startLine: r.startLine,
+		endLine: r.endLine,
+		source: r.source,
+		snippet: r.snippet,
+		vectorScore: r.vectorScore,
+		textScore: 0
+	});
+	for (const r of params.keyword) {
+		const existing = byId.get(r.id);
+		if (existing) {
+			existing.textScore = r.textScore;
+			if (r.snippet && r.snippet.length > 0) existing.snippet = r.snippet;
+		} else byId.set(r.id, {
+			id: r.id,
+			path: r.path,
+			startLine: r.startLine,
+			endLine: r.endLine,
+			source: r.source,
+			snippet: r.snippet,
+			vectorScore: 0,
+			textScore: r.textScore
+		});
+	}
+	const sorted = (await applyTemporalDecayToHybridResults({
+		results: Array.from(byId.values()).map((entry) => {
+			const score = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+			return {
+				path: entry.path,
+				startLine: entry.startLine,
+				endLine: entry.endLine,
+				score,
+				snippet: entry.snippet,
+				source: entry.source
+			};
+		}),
+		temporalDecay: {
+			...DEFAULT_TEMPORAL_DECAY_CONFIG,
+			...params.temporalDecay
+		},
+		workspaceDir: params.workspaceDir,
+		nowMs: params.nowMs
+	})).toSorted((a, b) => b.score - a.score);
+	const mmrConfig = {
+		...DEFAULT_MMR_CONFIG,
+		...params.mmr
+	};
+	if (mmrConfig.enabled) return applyMMRToHybridResults(sorted, mmrConfig);
+	return sorted;
+}
+//#endregion
+//#region src/memory/batch-utils.ts
+function normalizeBatchBaseUrl(client) {
+	return client.baseUrl?.replace(/\/$/, "") ?? "";
+}
+function buildBatchHeaders(client, params) {
+	const headers = client.headers ? { ...client.headers } : {};
+	if (params.json) {
+		if (!headers["Content-Type"] && !headers["content-type"]) headers["Content-Type"] = "application/json";
+	} else {
+		delete headers["Content-Type"];
+		delete headers["content-type"];
+	}
+	return headers;
+}
+function splitBatchRequests(requests, maxRequests) {
+	if (requests.length <= maxRequests) return [requests];
+	const groups = [];
+	for (let i = 0; i < requests.length; i += maxRequests) groups.push(requests.slice(i, i + maxRequests));
+	return groups;
+}
+//#endregion
+//#region src/memory/batch-runner.ts
+async function runEmbeddingBatchGroups(params) {
+	if (params.requests.length === 0) return /* @__PURE__ */ new Map();
+	const groups = splitBatchRequests(params.requests, params.maxRequests);
+	const byCustomId = /* @__PURE__ */ new Map();
+	const tasks = groups.map((group, groupIndex) => async () => {
+		await params.runGroup({
+			group,
+			groupIndex,
+			groups: groups.length,
+			byCustomId
+		});
+	});
+	params.debug?.(params.debugLabel, {
+		requests: params.requests.length,
+		groups: groups.length,
+		wait: params.wait,
+		concurrency: params.concurrency,
+		pollIntervalMs: params.pollIntervalMs,
+		timeoutMs: params.timeoutMs
+	});
+	await runWithConcurrency(tasks, params.concurrency);
+	return byCustomId;
+}
+function buildEmbeddingBatchGroupOptions(params, options) {
+	return {
+		requests: params.requests,
+		maxRequests: options.maxRequests,
+		wait: params.wait,
+		pollIntervalMs: params.pollIntervalMs,
+		timeoutMs: params.timeoutMs,
+		concurrency: params.concurrency,
+		debug: params.debug,
+		debugLabel: options.debugLabel
+	};
+}
+//#endregion
+//#region src/memory/batch-gemini.ts
+const GEMINI_BATCH_MAX_REQUESTS = 5e4;
+function getGeminiUploadUrl(baseUrl) {
+	if (baseUrl.includes("/v1beta")) return baseUrl.replace(/\/v1beta\/?$/, "/upload/v1beta");
+	return `${baseUrl.replace(/\/$/, "")}/upload`;
+}
+function buildGeminiUploadBody(params) {
+	const boundary = `openclaw-${hashText(params.displayName)}`;
+	const jsonPart = JSON.stringify({ file: {
+		displayName: params.displayName,
+		mimeType: "application/jsonl"
+	} });
+	const delimiter = `--${boundary}\r\n`;
+	const closeDelimiter = `--${boundary}--\r\n`;
+	const parts = [
+		`${delimiter}Content-Type: application/json; charset=UTF-8\r\n\r\n${jsonPart}\r\n`,
+		`${delimiter}Content-Type: application/jsonl; charset=UTF-8\r\n\r\n${params.jsonl}\r\n`,
+		closeDelimiter
+	];
+	return {
+		body: new Blob([parts.join("")], { type: "multipart/related" }),
+		contentType: `multipart/related; boundary=${boundary}`
+	};
+}
+async function submitGeminiBatch(params) {
+	const baseUrl = normalizeBatchBaseUrl(params.gemini);
+	const uploadPayload = buildGeminiUploadBody({
+		jsonl: params.requests.map((request) => JSON.stringify({
+			key: request.custom_id,
+			request: request.request
+		})).join("\n"),
+		displayName: `memory-embeddings-${hashText(String(Date.now()))}`
+	});
+	const uploadUrl = `${getGeminiUploadUrl(baseUrl)}/files?uploadType=multipart`;
+	debugEmbeddingsLog("memory embeddings: gemini batch upload", {
+		uploadUrl,
+		baseUrl,
+		requests: params.requests.length
+	});
+	const filePayload = await withRemoteHttpResponse({
+		url: uploadUrl,
+		ssrfPolicy: params.gemini.ssrfPolicy,
+		init: {
+			method: "POST",
+			headers: {
+				...buildBatchHeaders(params.gemini, { json: false }),
+				"Content-Type": uploadPayload.contentType
+			},
+			body: uploadPayload.body
+		},
+		onResponse: async (fileRes) => {
+			if (!fileRes.ok) {
+				const text = await fileRes.text();
+				throw new Error(`gemini batch file upload failed: ${fileRes.status} ${text}`);
+			}
+			return await fileRes.json();
+		}
+	});
+	const fileId = filePayload.name ?? filePayload.file?.name;
+	if (!fileId) throw new Error("gemini batch file upload failed: missing file id");
+	const batchBody = { batch: {
+		displayName: `memory-embeddings-${params.agentId}`,
+		inputConfig: { file_name: fileId }
+	} };
+	const batchEndpoint = `${baseUrl}/${params.gemini.modelPath}:asyncBatchEmbedContent`;
+	debugEmbeddingsLog("memory embeddings: gemini batch create", {
+		batchEndpoint,
+		fileId
+	});
+	return await withRemoteHttpResponse({
+		url: batchEndpoint,
+		ssrfPolicy: params.gemini.ssrfPolicy,
+		init: {
+			method: "POST",
+			headers: buildBatchHeaders(params.gemini, { json: true }),
+			body: JSON.stringify(batchBody)
+		},
+		onResponse: async (batchRes) => {
+			if (batchRes.ok) return await batchRes.json();
+			const text = await batchRes.text();
+			if (batchRes.status === 404) throw new Error("gemini batch create failed: 404 (asyncBatchEmbedContent not available for this model/baseUrl). Disable remote.batch.enabled or switch providers.");
+			throw new Error(`gemini batch create failed: ${batchRes.status} ${text}`);
+		}
+	});
+}
+async function fetchGeminiBatchStatus(params) {
+	const statusUrl = `${normalizeBatchBaseUrl(params.gemini)}/${params.batchName.startsWith("batches/") ? params.batchName : `batches/${params.batchName}`}`;
+	debugEmbeddingsLog("memory embeddings: gemini batch status", { statusUrl });
+	return await withRemoteHttpResponse({
+		url: statusUrl,
+		ssrfPolicy: params.gemini.ssrfPolicy,
+		init: { headers: buildBatchHeaders(params.gemini, { json: true }) },
+		onResponse: async (res) => {
+			if (!res.ok) {
+				const text = await res.text();
+				throw new Error(`gemini batch status failed: ${res.status} ${text}`);
+			}
+			return await res.json();
+		}
+	});
+}
+async function fetchGeminiFileContent(params) {
+	const downloadUrl = `${normalizeBatchBaseUrl(params.gemini)}/${params.fileId.startsWith("files/") ? params.fileId : `files/${params.fileId}`}:download`;
+	debugEmbeddingsLog("memory embeddings: gemini batch download", { downloadUrl });
+	return await withRemoteHttpResponse({
+		url: downloadUrl,
+		ssrfPolicy: params.gemini.ssrfPolicy,
+		init: { headers: buildBatchHeaders(params.gemini, { json: true }) },
+		onResponse: async (res) => {
+			if (!res.ok) {
+				const text = await res.text();
+				throw new Error(`gemini batch file content failed: ${res.status} ${text}`);
+			}
+			return await res.text();
+		}
+	});
+}
+function parseGeminiBatchOutput(text) {
+	if (!text.trim()) return [];
+	return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function waitForGeminiBatch(params) {
+	const start = Date.now();
+	let current = params.initial;
+	while (true) {
+		const status = current ?? await fetchGeminiBatchStatus({
+			gemini: params.gemini,
+			batchName: params.batchName
+		});
+		const state = status.state ?? "UNKNOWN";
+		if ([
+			"SUCCEEDED",
+			"COMPLETED",
+			"DONE"
+		].includes(state)) {
+			const outputFileId = status.outputConfig?.file ?? status.outputConfig?.fileId ?? status.metadata?.output?.responsesFile;
+			if (!outputFileId) throw new Error(`gemini batch ${params.batchName} completed without output file`);
+			return { outputFileId };
+		}
+		if ([
+			"FAILED",
+			"CANCELLED",
+			"CANCELED",
+			"EXPIRED"
+		].includes(state)) {
+			const message = status.error?.message ?? "unknown error";
+			throw new Error(`gemini batch ${params.batchName} ${state}: ${message}`);
+		}
+		if (!params.wait) throw new Error(`gemini batch ${params.batchName} still ${state}; wait disabled`);
+		if (Date.now() - start > params.timeoutMs) throw new Error(`gemini batch ${params.batchName} timed out after ${params.timeoutMs}ms`);
+		params.debug?.(`gemini batch ${params.batchName} ${state}; waiting ${params.pollIntervalMs}ms`);
+		await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+		current = void 0;
+	}
+}
+async function runGeminiEmbeddingBatches(params) {
+	return await runEmbeddingBatchGroups({
+		...buildEmbeddingBatchGroupOptions(params, {
+			maxRequests: GEMINI_BATCH_MAX_REQUESTS,
+			debugLabel: "memory embeddings: gemini batch submit"
+		}),
+		runGroup: async ({ group, groupIndex, groups, byCustomId }) => {
+			const batchInfo = await submitGeminiBatch({
+				gemini: params.gemini,
+				requests: group,
+				agentId: params.agentId
+			});
+			const batchName = batchInfo.name ?? "";
+			if (!batchName) throw new Error("gemini batch create failed: missing batch name");
+			params.debug?.("memory embeddings: gemini batch created", {
+				batchName,
+				state: batchInfo.state,
+				group: groupIndex + 1,
+				groups,
+				requests: group.length
+			});
+			if (!params.wait && batchInfo.state && ![
+				"SUCCEEDED",
+				"COMPLETED",
+				"DONE"
+			].includes(batchInfo.state)) throw new Error(`gemini batch ${batchName} submitted; enable remote.batch.wait to await completion`);
+			const completed = batchInfo.state && [
+				"SUCCEEDED",
+				"COMPLETED",
+				"DONE"
+			].includes(batchInfo.state) ? { outputFileId: batchInfo.outputConfig?.file ?? batchInfo.outputConfig?.fileId ?? batchInfo.metadata?.output?.responsesFile ?? "" } : await waitForGeminiBatch({
+				gemini: params.gemini,
+				batchName,
+				wait: params.wait,
+				pollIntervalMs: params.pollIntervalMs,
+				timeoutMs: params.timeoutMs,
+				debug: params.debug,
+				initial: batchInfo
+			});
+			if (!completed.outputFileId) throw new Error(`gemini batch ${batchName} completed without output file`);
+			const outputLines = parseGeminiBatchOutput(await fetchGeminiFileContent({
+				gemini: params.gemini,
+				fileId: completed.outputFileId
+			}));
+			const errors = [];
+			const remaining = new Set(group.map((request) => request.custom_id));
+			for (const line of outputLines) {
+				const customId = line.key ?? line.custom_id ?? line.request_id;
+				if (!customId) continue;
+				remaining.delete(customId);
+				if (line.error?.message) {
+					errors.push(`${customId}: ${line.error.message}`);
+					continue;
+				}
+				if (line.response?.error?.message) {
+					errors.push(`${customId}: ${line.response.error.message}`);
+					continue;
+				}
+				const embedding = sanitizeAndNormalizeEmbedding(line.embedding?.values ?? line.response?.embedding?.values ?? []);
+				if (embedding.length === 0) {
+					errors.push(`${customId}: empty embedding`);
+					continue;
+				}
+				byCustomId.set(customId, embedding);
+			}
+			if (errors.length > 0) throw new Error(`gemini batch ${batchName} failed: ${errors.join("; ")}`);
+			if (remaining.size > 0) throw new Error(`gemini batch ${batchName} missing ${remaining.size} embedding responses`);
+		}
+	});
+}
+//#endregion
+//#region src/memory/batch-error-utils.ts
+function getResponseErrorMessage(line) {
+	const body = line?.response?.body;
+	if (typeof body === "string") return body || void 0;
+	if (!body || typeof body !== "object") return;
+	return typeof body.error?.message === "string" ? body.error.message : void 0;
+}
+function extractBatchErrorMessage(lines) {
+	const first = lines.find((line) => line.error?.message || getResponseErrorMessage(line));
+	return first?.error?.message ?? getResponseErrorMessage(first);
+}
+function formatUnavailableBatchError(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	return message ? `error file unavailable: ${message}` : void 0;
+}
+//#endregion
+//#region src/memory/batch-http.ts
+async function postJsonWithRetry(params) {
+	return await retryAsync(async () => {
+		return await postJson({
+			url: params.url,
+			headers: params.headers,
+			ssrfPolicy: params.ssrfPolicy,
+			body: params.body,
+			errorPrefix: params.errorPrefix,
+			attachStatus: true,
+			parse: async (payload) => payload
+		});
+	}, {
+		attempts: 3,
+		minDelayMs: 300,
+		maxDelayMs: 2e3,
+		jitter: .2,
+		shouldRetry: (err) => {
+			const status = err.status;
+			return status === 429 || typeof status === "number" && status >= 500;
+		}
+	});
+}
+//#endregion
+//#region src/memory/batch-output.ts
+function applyEmbeddingBatchOutputLine(params) {
+	const customId = params.line.custom_id;
+	if (!customId) return;
+	params.remaining.delete(customId);
+	const errorMessage = params.line.error?.message;
+	if (errorMessage) {
+		params.errors.push(`${customId}: ${errorMessage}`);
+		return;
+	}
+	const response = params.line.response;
+	if ((response?.status_code ?? 0) >= 400) {
+		const messageFromObject = response?.body && typeof response.body === "object" ? response.body.error?.message : void 0;
+		const messageFromString = typeof response?.body === "string" ? response.body : void 0;
+		params.errors.push(`${customId}: ${messageFromObject ?? messageFromString ?? "unknown error"}`);
+		return;
+	}
+	const embedding = (response?.body && typeof response.body === "object" ? response.body.data ?? [] : [])[0]?.embedding ?? [];
+	if (embedding.length === 0) {
+		params.errors.push(`${customId}: empty embedding`);
+		return;
+	}
+	params.byCustomId.set(customId, embedding);
+}
+//#endregion
+//#region src/memory/batch-status.ts
+const TERMINAL_FAILURE_STATES = new Set([
+	"failed",
+	"expired",
+	"cancelled",
+	"canceled"
+]);
+function resolveBatchCompletionFromStatus(params) {
+	if (!params.status.output_file_id) throw new Error(`${params.provider} batch ${params.batchId} completed without output file`);
+	return {
+		outputFileId: params.status.output_file_id,
+		errorFileId: params.status.error_file_id ?? void 0
+	};
+}
+async function throwIfBatchTerminalFailure(params) {
+	const state = params.status.status ?? "unknown";
+	if (!TERMINAL_FAILURE_STATES.has(state)) return;
+	const detail = params.status.error_file_id ? await params.readError(params.status.error_file_id) : void 0;
+	const suffix = detail ? `: ${detail}` : "";
+	throw new Error(`${params.provider} batch ${params.status.id ?? "<unknown>"} ${state}${suffix}`);
+}
+async function resolveCompletedBatchResult(params) {
+	const batchId = params.status.id ?? "<unknown>";
+	if (!params.wait && params.status.status !== "completed") throw new Error(`${params.provider} batch ${batchId} submitted; enable remote.batch.wait to await completion`);
+	const completed = params.status.status === "completed" ? resolveBatchCompletionFromStatus({
+		provider: params.provider,
+		batchId,
+		status: params.status
+	}) : await params.waitForBatch();
+	if (!completed.outputFileId) throw new Error(`${params.provider} batch ${batchId} completed without output file`);
+	return completed;
+}
+//#endregion
+//#region src/memory/batch-provider-common.ts
+const EMBEDDING_BATCH_ENDPOINT = "/v1/embeddings";
+//#endregion
+//#region src/memory/batch-upload.ts
+async function uploadBatchJsonlFile(params) {
+	const baseUrl = normalizeBatchBaseUrl(params.client);
+	const jsonl = params.requests.map((request) => JSON.stringify(request)).join("\n");
+	const form = new FormData();
+	form.append("purpose", "batch");
+	form.append("file", new Blob([jsonl], { type: "application/jsonl" }), `memory-embeddings.${hashText(String(Date.now()))}.jsonl`);
+	const filePayload = await withRemoteHttpResponse({
+		url: `${baseUrl}/files`,
+		ssrfPolicy: params.client.ssrfPolicy,
+		init: {
+			method: "POST",
+			headers: buildBatchHeaders(params.client, { json: false }),
+			body: form
+		},
+		onResponse: async (fileRes) => {
+			if (!fileRes.ok) {
+				const text = await fileRes.text();
+				throw new Error(`${params.errorPrefix}: ${fileRes.status} ${text}`);
+			}
+			return await fileRes.json();
+		}
+	});
+	if (!filePayload.id) throw new Error(`${params.errorPrefix}: missing file id`);
+	return filePayload.id;
+}
+//#endregion
+//#region src/memory/batch-openai.ts
+const OPENAI_BATCH_ENDPOINT = EMBEDDING_BATCH_ENDPOINT;
+const OPENAI_BATCH_COMPLETION_WINDOW = "24h";
+const OPENAI_BATCH_MAX_REQUESTS = 5e4;
+async function submitOpenAiBatch(params) {
+	const baseUrl = normalizeBatchBaseUrl(params.openAi);
+	const inputFileId = await uploadBatchJsonlFile({
+		client: params.openAi,
+		requests: params.requests,
+		errorPrefix: "openai batch file upload failed"
+	});
+	return await postJsonWithRetry({
+		url: `${baseUrl}/batches`,
+		headers: buildBatchHeaders(params.openAi, { json: true }),
+		ssrfPolicy: params.openAi.ssrfPolicy,
+		body: {
+			input_file_id: inputFileId,
+			endpoint: OPENAI_BATCH_ENDPOINT,
+			completion_window: OPENAI_BATCH_COMPLETION_WINDOW,
+			metadata: {
+				source: "openclaw-memory",
+				agent: params.agentId
+			}
+		},
+		errorPrefix: "openai batch create failed"
+	});
+}
+async function fetchOpenAiBatchStatus(params) {
+	return await fetchOpenAiBatchResource({
+		openAi: params.openAi,
+		path: `/batches/${params.batchId}`,
+		errorPrefix: "openai batch status",
+		parse: async (res) => await res.json()
+	});
+}
+async function fetchOpenAiFileContent(params) {
+	return await fetchOpenAiBatchResource({
+		openAi: params.openAi,
+		path: `/files/${params.fileId}/content`,
+		errorPrefix: "openai batch file content",
+		parse: async (res) => await res.text()
+	});
+}
+async function fetchOpenAiBatchResource(params) {
+	return await withRemoteHttpResponse({
+		url: `${normalizeBatchBaseUrl(params.openAi)}${params.path}`,
+		ssrfPolicy: params.openAi.ssrfPolicy,
+		init: { headers: buildBatchHeaders(params.openAi, { json: true }) },
+		onResponse: async (res) => {
+			if (!res.ok) {
+				const text = await res.text();
+				throw new Error(`${params.errorPrefix} failed: ${res.status} ${text}`);
+			}
+			return await params.parse(res);
+		}
+	});
+}
+function parseOpenAiBatchOutput(text) {
+	if (!text.trim()) return [];
+	return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function readOpenAiBatchError(params) {
+	try {
+		return extractBatchErrorMessage(parseOpenAiBatchOutput(await fetchOpenAiFileContent({
+			openAi: params.openAi,
+			fileId: params.errorFileId
+		})));
+	} catch (err) {
+		return formatUnavailableBatchError(err);
+	}
+}
+async function waitForOpenAiBatch(params) {
+	const start = Date.now();
+	let current = params.initial;
+	while (true) {
+		const status = current ?? await fetchOpenAiBatchStatus({
+			openAi: params.openAi,
+			batchId: params.batchId
+		});
+		const state = status.status ?? "unknown";
+		if (state === "completed") return resolveBatchCompletionFromStatus({
+			provider: "openai",
+			batchId: params.batchId,
+			status
+		});
+		await throwIfBatchTerminalFailure({
+			provider: "openai",
+			status: {
+				...status,
+				id: params.batchId
+			},
+			readError: async (errorFileId) => await readOpenAiBatchError({
+				openAi: params.openAi,
+				errorFileId
+			})
+		});
+		if (!params.wait) throw new Error(`openai batch ${params.batchId} still ${state}; wait disabled`);
+		if (Date.now() - start > params.timeoutMs) throw new Error(`openai batch ${params.batchId} timed out after ${params.timeoutMs}ms`);
+		params.debug?.(`openai batch ${params.batchId} ${state}; waiting ${params.pollIntervalMs}ms`);
+		await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+		current = void 0;
+	}
+}
+async function runOpenAiEmbeddingBatches(params) {
+	return await runEmbeddingBatchGroups({
+		...buildEmbeddingBatchGroupOptions(params, {
+			maxRequests: OPENAI_BATCH_MAX_REQUESTS,
+			debugLabel: "memory embeddings: openai batch submit"
+		}),
+		runGroup: async ({ group, groupIndex, groups, byCustomId }) => {
+			const batchInfo = await submitOpenAiBatch({
+				openAi: params.openAi,
+				requests: group,
+				agentId: params.agentId
+			});
+			if (!batchInfo.id) throw new Error("openai batch create failed: missing batch id");
+			const batchId = batchInfo.id;
+			params.debug?.("memory embeddings: openai batch created", {
+				batchId: batchInfo.id,
+				status: batchInfo.status,
+				group: groupIndex + 1,
+				groups,
+				requests: group.length
+			});
+			const completed = await resolveCompletedBatchResult({
+				provider: "openai",
+				status: batchInfo,
+				wait: params.wait,
+				waitForBatch: async () => await waitForOpenAiBatch({
+					openAi: params.openAi,
+					batchId,
+					wait: params.wait,
+					pollIntervalMs: params.pollIntervalMs,
+					timeoutMs: params.timeoutMs,
+					debug: params.debug,
+					initial: batchInfo
+				})
+			});
+			const outputLines = parseOpenAiBatchOutput(await fetchOpenAiFileContent({
+				openAi: params.openAi,
+				fileId: completed.outputFileId
+			}));
+			const errors = [];
+			const remaining = new Set(group.map((request) => request.custom_id));
+			for (const line of outputLines) applyEmbeddingBatchOutputLine({
+				line,
+				remaining,
+				errors,
+				byCustomId
+			});
+			if (errors.length > 0) throw new Error(`openai batch ${batchInfo.id} failed: ${errors.join("; ")}`);
+			if (remaining.size > 0) throw new Error(`openai batch ${batchInfo.id} missing ${remaining.size} embedding responses`);
+		}
+	});
+}
+//#endregion
+//#region src/memory/batch-voyage.ts
+const VOYAGE_BATCH_ENDPOINT = EMBEDDING_BATCH_ENDPOINT;
+const VOYAGE_BATCH_COMPLETION_WINDOW = "12h";
+const VOYAGE_BATCH_MAX_REQUESTS = 5e4;
+async function assertVoyageResponseOk(res, context) {
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error(`${context}: ${res.status} ${text}`);
+	}
+}
+function buildVoyageBatchRequest(params) {
+	return {
+		url: `${normalizeBatchBaseUrl(params.client)}/${params.path}`,
+		ssrfPolicy: params.client.ssrfPolicy,
+		init: { headers: buildBatchHeaders(params.client, { json: true }) },
+		onResponse: params.onResponse
+	};
+}
+async function submitVoyageBatch(params) {
+	const baseUrl = normalizeBatchBaseUrl(params.client);
+	const inputFileId = await uploadBatchJsonlFile({
+		client: params.client,
+		requests: params.requests,
+		errorPrefix: "voyage batch file upload failed"
+	});
+	return await postJsonWithRetry({
+		url: `${baseUrl}/batches`,
+		headers: buildBatchHeaders(params.client, { json: true }),
+		ssrfPolicy: params.client.ssrfPolicy,
+		body: {
+			input_file_id: inputFileId,
+			endpoint: VOYAGE_BATCH_ENDPOINT,
+			completion_window: VOYAGE_BATCH_COMPLETION_WINDOW,
+			request_params: {
+				model: params.client.model,
+				input_type: "document"
+			},
+			metadata: {
+				source: "clawdbot-memory",
+				agent: params.agentId
+			}
+		},
+		errorPrefix: "voyage batch create failed"
+	});
+}
+async function fetchVoyageBatchStatus(params) {
+	return await withRemoteHttpResponse(buildVoyageBatchRequest({
+		client: params.client,
+		path: `batches/${params.batchId}`,
+		onResponse: async (res) => {
+			await assertVoyageResponseOk(res, "voyage batch status failed");
+			return await res.json();
+		}
+	}));
+}
+async function readVoyageBatchError(params) {
+	try {
+		return await withRemoteHttpResponse(buildVoyageBatchRequest({
+			client: params.client,
+			path: `files/${params.errorFileId}/content`,
+			onResponse: async (res) => {
+				await assertVoyageResponseOk(res, "voyage batch error file content failed");
+				const text = await res.text();
+				if (!text.trim()) return;
+				return extractBatchErrorMessage(text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line)));
+			}
+		}));
+	} catch (err) {
+		return formatUnavailableBatchError(err);
+	}
+}
+async function waitForVoyageBatch(params) {
+	const start = Date.now();
+	let current = params.initial;
+	while (true) {
+		const status = current ?? await fetchVoyageBatchStatus({
+			client: params.client,
+			batchId: params.batchId
+		});
+		const state = status.status ?? "unknown";
+		if (state === "completed") return resolveBatchCompletionFromStatus({
+			provider: "voyage",
+			batchId: params.batchId,
+			status
+		});
+		await throwIfBatchTerminalFailure({
+			provider: "voyage",
+			status: {
+				...status,
+				id: params.batchId
+			},
+			readError: async (errorFileId) => await readVoyageBatchError({
+				client: params.client,
+				errorFileId
+			})
+		});
+		if (!params.wait) throw new Error(`voyage batch ${params.batchId} still ${state}; wait disabled`);
+		if (Date.now() - start > params.timeoutMs) throw new Error(`voyage batch ${params.batchId} timed out after ${params.timeoutMs}ms`);
+		params.debug?.(`voyage batch ${params.batchId} ${state}; waiting ${params.pollIntervalMs}ms`);
+		await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+		current = void 0;
+	}
+}
+async function runVoyageEmbeddingBatches(params) {
+	return await runEmbeddingBatchGroups({
+		...buildEmbeddingBatchGroupOptions(params, {
+			maxRequests: VOYAGE_BATCH_MAX_REQUESTS,
+			debugLabel: "memory embeddings: voyage batch submit"
+		}),
+		runGroup: async ({ group, groupIndex, groups, byCustomId }) => {
+			const batchInfo = await submitVoyageBatch({
+				client: params.client,
+				requests: group,
+				agentId: params.agentId
+			});
+			if (!batchInfo.id) throw new Error("voyage batch create failed: missing batch id");
+			const batchId = batchInfo.id;
+			params.debug?.("memory embeddings: voyage batch created", {
+				batchId: batchInfo.id,
+				status: batchInfo.status,
+				group: groupIndex + 1,
+				groups,
+				requests: group.length
+			});
+			const completed = await resolveCompletedBatchResult({
+				provider: "voyage",
+				status: batchInfo,
+				wait: params.wait,
+				waitForBatch: async () => await waitForVoyageBatch({
+					client: params.client,
+					batchId,
+					wait: params.wait,
+					pollIntervalMs: params.pollIntervalMs,
+					timeoutMs: params.timeoutMs,
+					debug: params.debug,
+					initial: batchInfo
+				})
+			});
+			const baseUrl = normalizeBatchBaseUrl(params.client);
+			const errors = [];
+			const remaining = new Set(group.map((request) => request.custom_id));
+			await withRemoteHttpResponse({
+				url: `${baseUrl}/files/${completed.outputFileId}/content`,
+				ssrfPolicy: params.client.ssrfPolicy,
+				init: { headers: buildBatchHeaders(params.client, { json: true }) },
+				onResponse: async (contentRes) => {
+					if (!contentRes.ok) {
+						const text = await contentRes.text();
+						throw new Error(`voyage batch file content failed: ${contentRes.status} ${text}`);
+					}
+					if (!contentRes.body) return;
+					const reader = createInterface({
+						input: Readable.fromWeb(contentRes.body),
+						terminal: false
+					});
+					for await (const rawLine of reader) {
+						if (!rawLine.trim()) continue;
+						applyEmbeddingBatchOutputLine({
+							line: JSON.parse(rawLine),
+							remaining,
+							errors,
+							byCustomId
+						});
+					}
+				}
+			});
+			if (errors.length > 0) throw new Error(`voyage batch ${batchInfo.id} failed: ${errors.join("; ")}`);
+			if (remaining.size > 0) throw new Error(`voyage batch ${batchInfo.id} missing ${remaining.size} embedding responses`);
+		}
+	});
+}
+//#endregion
+//#region src/memory/embedding-model-limits.ts
+const DEFAULT_EMBEDDING_MAX_INPUT_TOKENS = 8192;
+const DEFAULT_LOCAL_EMBEDDING_MAX_INPUT_TOKENS = 2048;
+const KNOWN_EMBEDDING_MAX_INPUT_TOKENS = {
+	"openai:text-embedding-3-small": 8192,
+	"openai:text-embedding-3-large": 8192,
+	"openai:text-embedding-ada-002": 8191,
+	"gemini:text-embedding-004": 2048,
+	"gemini:gemini-embedding-001": 2048,
+	"gemini:gemini-embedding-2-preview": 8192,
+	"voyage:voyage-3": 32e3,
+	"voyage:voyage-3-lite": 16e3,
+	"voyage:voyage-code-3": 32e3
+};
+function resolveEmbeddingMaxInputTokens(provider) {
+	if (typeof provider.maxInputTokens === "number") return provider.maxInputTokens;
+	const known = KNOWN_EMBEDDING_MAX_INPUT_TOKENS[`${provider.id}:${provider.model}`.toLowerCase()];
+	if (typeof known === "number") return known;
+	if (provider.id.toLowerCase() === "gemini") return 2048;
+	if (provider.id.toLowerCase() === "local") return DEFAULT_LOCAL_EMBEDDING_MAX_INPUT_TOKENS;
+	return DEFAULT_EMBEDDING_MAX_INPUT_TOKENS;
+}
+//#endregion
+//#region src/memory/embedding-chunk-limits.ts
+function enforceEmbeddingMaxInputTokens(provider, chunks, hardMaxInputTokens) {
+	const providerMaxInputTokens = resolveEmbeddingMaxInputTokens(provider);
+	const maxInputTokens = typeof hardMaxInputTokens === "number" && hardMaxInputTokens > 0 ? Math.min(providerMaxInputTokens, hardMaxInputTokens) : providerMaxInputTokens;
+	const out = [];
+	for (const chunk of chunks) {
+		if (hasNonTextEmbeddingParts(chunk.embeddingInput)) {
+			out.push(chunk);
+			continue;
+		}
+		if (estimateUtf8Bytes(chunk.text) <= maxInputTokens) {
+			out.push(chunk);
+			continue;
+		}
+		for (const text of splitTextToUtf8ByteLimit(chunk.text, maxInputTokens)) out.push({
+			startLine: chunk.startLine,
+			endLine: chunk.endLine,
+			text,
+			hash: hashText(text),
+			embeddingInput: { text }
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/memory/memory-schema.ts
+function ensureMemoryIndexSchema(params) {
+	params.db.exec(`
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+	params.db.exec(`
+    CREATE TABLE IF NOT EXISTS files (
+      path TEXT PRIMARY KEY,
+      source TEXT NOT NULL DEFAULT 'memory',
+      hash TEXT NOT NULL,
+      mtime INTEGER NOT NULL,
+      size INTEGER NOT NULL
+    );
+  `);
+	params.db.exec(`
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'memory',
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      hash TEXT NOT NULL,
+      model TEXT NOT NULL,
+      text TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+	if (params.cacheEnabled) {
+		params.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${params.embeddingCacheTable} (
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        provider_key TEXT NOT NULL,
+        hash TEXT NOT NULL,
+        embedding TEXT NOT NULL,
+        dims INTEGER,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (provider, model, provider_key, hash)
+      );
+    `);
+		params.db.exec(`CREATE INDEX IF NOT EXISTS idx_embedding_cache_updated_at ON ${params.embeddingCacheTable}(updated_at);`);
+	}
+	let ftsAvailable = false;
+	let ftsError;
+	if (params.ftsEnabled) try {
+		params.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${params.ftsTable} USING fts5(\n  text,\n  id UNINDEXED,\n  path UNINDEXED,\n  source UNINDEXED,\n  model UNINDEXED,\n  start_line UNINDEXED,\n  end_line UNINDEXED\n);`);
+		ftsAvailable = true;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		ftsAvailable = false;
+		ftsError = message;
+	}
+	ensureColumn(params.db, "files", "source", "TEXT NOT NULL DEFAULT 'memory'");
+	ensureColumn(params.db, "chunks", "source", "TEXT NOT NULL DEFAULT 'memory'");
+	params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);`);
+	params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source);`);
+	return {
+		ftsAvailable,
+		...ftsError ? { ftsError } : {}
+	};
+}
+function ensureColumn(db, table, column, definition) {
+	if (db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column)) return;
+	db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}
+//#endregion
+//#region src/memory/sqlite-vec.ts
+async function loadSqliteVecExtension(params) {
+	try {
+		const sqliteVec = await import("sqlite-vec");
+		const resolvedPath = params.extensionPath?.trim() ? params.extensionPath.trim() : void 0;
+		const extensionPath = resolvedPath ?? sqliteVec.getLoadablePath();
+		params.db.enableLoadExtension(true);
+		if (resolvedPath) params.db.loadExtension(extensionPath);
+		else sqliteVec.load(params.db);
+		return {
+			ok: true,
+			extensionPath
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+//#endregion
+//#region src/memory/manager-sync-ops.ts
+const META_KEY = "memory_index_meta_v1";
+const VECTOR_TABLE$2 = "chunks_vec";
+const FTS_TABLE$2 = "chunks_fts";
+const EMBEDDING_CACHE_TABLE$2 = "embedding_cache";
+const SESSION_DIRTY_DEBOUNCE_MS = 5e3;
+const SESSION_DELTA_READ_CHUNK_BYTES = 64 * 1024;
+const VECTOR_LOAD_TIMEOUT_MS = 3e4;
+const IGNORED_MEMORY_WATCH_DIR_NAMES = new Set([
+	".git",
+	"node_modules",
+	".pnpm-store",
+	".venv",
+	"venv",
+	".tox",
+	"__pycache__"
+]);
+const log$2 = createSubsystemLogger("memory");
+function shouldIgnoreMemoryWatchPath(watchPath) {
+	return path.normalize(watchPath).split(path.sep).map((segment) => segment.trim().toLowerCase()).some((segment) => IGNORED_MEMORY_WATCH_DIR_NAMES.has(segment));
+}
+function runDetachedMemorySync(sync, reason) {
+	sync().catch((err) => {
+		log$2.warn(`memory sync failed (${reason}): ${String(err)}`);
+	});
+}
+var MemoryManagerSyncOps = class {
+	constructor() {
+		this.provider = null;
+		this.sources = /* @__PURE__ */ new Set();
+		this.providerKey = null;
+		this.fts = {
+			enabled: false,
+			available: false
+		};
+		this.vectorReady = null;
+		this.watcher = null;
+		this.watchTimer = null;
+		this.sessionWatchTimer = null;
+		this.sessionUnsubscribe = null;
+		this.intervalTimer = null;
+		this.closed = false;
+		this.dirty = false;
+		this.sessionsDirty = false;
+		this.sessionsDirtyFiles = /* @__PURE__ */ new Set();
+		this.sessionPendingFiles = /* @__PURE__ */ new Set();
+		this.sessionDeltas = /* @__PURE__ */ new Map();
+		this.lastMetaSerialized = null;
+	}
+	async ensureVectorReady(dimensions) {
+		if (!this.vector.enabled) return false;
+		if (!this.vectorReady) this.vectorReady = this.withTimeout(this.loadVectorExtension(), VECTOR_LOAD_TIMEOUT_MS, `sqlite-vec load timed out after ${Math.round(VECTOR_LOAD_TIMEOUT_MS / 1e3)}s`);
+		let ready = false;
+		try {
+			ready = await this.vectorReady || false;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this.vector.available = false;
+			this.vector.loadError = message;
+			this.vectorReady = null;
+			log$2.warn(`sqlite-vec unavailable: ${message}`);
+			return false;
+		}
+		if (ready && typeof dimensions === "number" && dimensions > 0) this.ensureVectorTable(dimensions);
+		return ready;
+	}
+	async loadVectorExtension() {
+		if (this.vector.available !== null) return this.vector.available;
+		if (!this.vector.enabled) {
+			this.vector.available = false;
+			return false;
+		}
+		try {
+			const resolvedPath = this.vector.extensionPath?.trim() ? resolveUserPath(this.vector.extensionPath) : void 0;
+			const loaded = await loadSqliteVecExtension({
+				db: this.db,
+				extensionPath: resolvedPath
+			});
+			if (!loaded.ok) throw new Error(loaded.error ?? "unknown sqlite-vec load error");
+			this.vector.extensionPath = loaded.extensionPath;
+			this.vector.available = true;
+			return true;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this.vector.available = false;
+			this.vector.loadError = message;
+			log$2.warn(`sqlite-vec unavailable: ${message}`);
+			return false;
+		}
+	}
+	ensureVectorTable(dimensions) {
+		if (this.vector.dims === dimensions) return;
+		if (this.vector.dims && this.vector.dims !== dimensions) this.dropVectorTable();
+		this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${VECTOR_TABLE$2} USING vec0(\n  id TEXT PRIMARY KEY,\n  embedding FLOAT[${dimensions}]\n)`);
+		this.vector.dims = dimensions;
+	}
+	dropVectorTable() {
+		try {
+			this.db.exec(`DROP TABLE IF EXISTS ${VECTOR_TABLE$2}`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			log$2.debug(`Failed to drop ${VECTOR_TABLE$2}: ${message}`);
+		}
+	}
+	buildSourceFilter(alias) {
+		const sources = Array.from(this.sources);
+		if (sources.length === 0) return {
+			sql: "",
+			params: []
+		};
+		return {
+			sql: ` AND ${alias ? `${alias}.source` : "source"} IN (${sources.map(() => "?").join(", ")})`,
+			params: sources
+		};
+	}
+	openDatabase() {
+		const dbPath = resolveUserPath(this.settings.store.path);
+		return this.openDatabaseAtPath(dbPath);
+	}
+	openDatabaseAtPath(dbPath) {
+		ensureDir(path.dirname(dbPath));
+		const { DatabaseSync } = requireNodeSqlite();
+		const db = new DatabaseSync(dbPath, { allowExtension: this.settings.store.vector.enabled });
+		db.exec("PRAGMA busy_timeout = 5000");
+		return db;
+	}
+	seedEmbeddingCache(sourceDb) {
+		if (!this.cache.enabled) return;
+		try {
+			const rows = sourceDb.prepare(`SELECT provider, model, provider_key, hash, embedding, dims, updated_at FROM ${EMBEDDING_CACHE_TABLE$2}`).all();
+			if (!rows.length) return;
+			const insert = this.db.prepare(`INSERT INTO ${EMBEDDING_CACHE_TABLE$2} (provider, model, provider_key, hash, embedding, dims, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(provider, model, provider_key, hash) DO UPDATE SET
+           embedding=excluded.embedding,
+           dims=excluded.dims,
+           updated_at=excluded.updated_at`);
+			this.db.exec("BEGIN");
+			for (const row of rows) insert.run(row.provider, row.model, row.provider_key, row.hash, row.embedding, row.dims, row.updated_at);
+			this.db.exec("COMMIT");
+		} catch (err) {
+			try {
+				this.db.exec("ROLLBACK");
+			} catch {}
+			throw err;
+		}
+	}
+	async swapIndexFiles(targetPath, tempPath) {
+		const backupPath = `${targetPath}.backup-${randomUUID()}`;
+		await this.moveIndexFiles(targetPath, backupPath);
+		try {
+			await this.moveIndexFiles(tempPath, targetPath);
+		} catch (err) {
+			await this.moveIndexFiles(backupPath, targetPath);
+			throw err;
+		}
+		await this.removeIndexFiles(backupPath);
+	}
+	async moveIndexFiles(sourceBase, targetBase) {
+		for (const suffix of [
+			"",
+			"-wal",
+			"-shm"
+		]) {
+			const source = `${sourceBase}${suffix}`;
+			const target = `${targetBase}${suffix}`;
+			try {
+				await fs$1.rename(source, target);
+			} catch (err) {
+				if (err.code !== "ENOENT") throw err;
+			}
+		}
+	}
+	async removeIndexFiles(basePath) {
+		await Promise.all([
+			"",
+			"-wal",
+			"-shm"
+		].map((suffix) => fs$1.rm(`${basePath}${suffix}`, { force: true })));
+	}
+	ensureSchema() {
+		const result = ensureMemoryIndexSchema({
+			db: this.db,
+			embeddingCacheTable: EMBEDDING_CACHE_TABLE$2,
+			cacheEnabled: this.cache.enabled,
+			ftsTable: FTS_TABLE$2,
+			ftsEnabled: this.fts.enabled
+		});
+		this.fts.available = result.ftsAvailable;
+		if (result.ftsError) {
+			this.fts.loadError = result.ftsError;
+			if (this.fts.enabled) log$2.warn(`fts unavailable: ${result.ftsError}`);
+		}
+	}
+	ensureWatcher() {
+		if (!this.sources.has("memory") || !this.settings.sync.watch || this.watcher) return;
+		const watchPaths = new Set([
+			path.join(this.workspaceDir, "MEMORY.md"),
+			path.join(this.workspaceDir, "memory.md"),
+			path.join(this.workspaceDir, "memory", "**", "*.md")
+		]);
+		const additionalPaths = normalizeExtraMemoryPaths(this.workspaceDir, this.settings.extraPaths);
+		for (const entry of additionalPaths) try {
+			const stat = fs.lstatSync(entry);
+			if (stat.isSymbolicLink()) continue;
+			if (stat.isDirectory()) {
+				watchPaths.add(path.join(entry, "**", "*.md"));
+				if (this.settings.multimodal.enabled) for (const modality of this.settings.multimodal.modalities) for (const extension of getMemoryMultimodalExtensions(modality)) watchPaths.add(path.join(entry, "**", buildCaseInsensitiveExtensionGlob(extension)));
+				continue;
+			}
+			if (stat.isFile() && (entry.toLowerCase().endsWith(".md") || classifyMemoryMultimodalPath(entry, this.settings.multimodal) !== null)) watchPaths.add(entry);
+		} catch {}
+		this.watcher = chokidar.watch(Array.from(watchPaths), {
+			ignoreInitial: true,
+			ignored: (watchPath) => shouldIgnoreMemoryWatchPath(String(watchPath)),
+			awaitWriteFinish: {
+				stabilityThreshold: this.settings.sync.watchDebounceMs,
+				pollInterval: 100
+			}
+		});
+		const markDirty = () => {
+			this.dirty = true;
+			this.scheduleWatchSync();
+		};
+		this.watcher.on("add", markDirty);
+		this.watcher.on("change", markDirty);
+		this.watcher.on("unlink", markDirty);
+	}
+	ensureSessionListener() {
+		if (!this.sources.has("sessions") || this.sessionUnsubscribe) return;
+		this.sessionUnsubscribe = onSessionTranscriptUpdate((update) => {
+			if (this.closed) return;
+			const sessionFile = update.sessionFile;
+			if (!this.isSessionFileForAgent(sessionFile)) return;
+			this.scheduleSessionDirty(sessionFile);
+		});
+	}
+	scheduleSessionDirty(sessionFile) {
+		this.sessionPendingFiles.add(sessionFile);
+		if (this.sessionWatchTimer) return;
+		this.sessionWatchTimer = setTimeout(() => {
+			this.sessionWatchTimer = null;
+			this.processSessionDeltaBatch().catch((err) => {
+				log$2.warn(`memory session delta failed: ${String(err)}`);
+			});
+		}, SESSION_DIRTY_DEBOUNCE_MS);
+	}
+	async processSessionDeltaBatch() {
+		if (this.sessionPendingFiles.size === 0) return;
+		const pending = Array.from(this.sessionPendingFiles);
+		this.sessionPendingFiles.clear();
+		let shouldSync = false;
+		for (const sessionFile of pending) {
+			const delta = await this.updateSessionDelta(sessionFile);
+			if (!delta) continue;
+			const bytesThreshold = delta.deltaBytes;
+			const messagesThreshold = delta.deltaMessages;
+			const bytesHit = bytesThreshold <= 0 ? delta.pendingBytes > 0 : delta.pendingBytes >= bytesThreshold;
+			const messagesHit = messagesThreshold <= 0 ? delta.pendingMessages > 0 : delta.pendingMessages >= messagesThreshold;
+			if (!bytesHit && !messagesHit) continue;
+			this.sessionsDirtyFiles.add(sessionFile);
+			this.sessionsDirty = true;
+			delta.pendingBytes = bytesThreshold > 0 ? Math.max(0, delta.pendingBytes - bytesThreshold) : 0;
+			delta.pendingMessages = messagesThreshold > 0 ? Math.max(0, delta.pendingMessages - messagesThreshold) : 0;
+			shouldSync = true;
+		}
+		if (shouldSync) this.sync({ reason: "session-delta" }).catch((err) => {
+			log$2.warn(`memory sync failed (session-delta): ${String(err)}`);
+		});
+	}
+	async updateSessionDelta(sessionFile) {
+		const thresholds = this.settings.sync.sessions;
+		if (!thresholds) return null;
+		let stat;
+		try {
+			stat = await fs$1.stat(sessionFile);
+		} catch {
+			return null;
+		}
+		const size = stat.size;
+		let state = this.sessionDeltas.get(sessionFile);
+		if (!state) {
+			state = {
+				lastSize: 0,
+				pendingBytes: 0,
+				pendingMessages: 0
+			};
+			this.sessionDeltas.set(sessionFile, state);
+		}
+		const deltaBytes = Math.max(0, size - state.lastSize);
+		if (deltaBytes === 0 && size === state.lastSize) return {
+			deltaBytes: thresholds.deltaBytes,
+			deltaMessages: thresholds.deltaMessages,
+			pendingBytes: state.pendingBytes,
+			pendingMessages: state.pendingMessages
+		};
+		if (size < state.lastSize) {
+			state.lastSize = size;
+			state.pendingBytes += size;
+			if (thresholds.deltaMessages > 0 && (thresholds.deltaBytes <= 0 || state.pendingBytes < thresholds.deltaBytes)) state.pendingMessages += await this.countNewlines(sessionFile, 0, size);
+		} else {
+			state.pendingBytes += deltaBytes;
+			if (thresholds.deltaMessages > 0 && (thresholds.deltaBytes <= 0 || state.pendingBytes < thresholds.deltaBytes)) state.pendingMessages += await this.countNewlines(sessionFile, state.lastSize, size);
+			state.lastSize = size;
+		}
+		this.sessionDeltas.set(sessionFile, state);
+		return {
+			deltaBytes: thresholds.deltaBytes,
+			deltaMessages: thresholds.deltaMessages,
+			pendingBytes: state.pendingBytes,
+			pendingMessages: state.pendingMessages
+		};
+	}
+	async countNewlines(absPath, start, end) {
+		if (end <= start) return 0;
+		let handle;
+		try {
+			handle = await fs$1.open(absPath, "r");
+		} catch (err) {
+			if (isFileMissingError(err)) return 0;
+			throw err;
+		}
+		try {
+			let offset = start;
+			let count = 0;
+			const buffer = Buffer.alloc(SESSION_DELTA_READ_CHUNK_BYTES);
+			while (offset < end) {
+				const toRead = Math.min(buffer.length, end - offset);
+				const { bytesRead } = await handle.read(buffer, 0, toRead, offset);
+				if (bytesRead <= 0) break;
+				for (let i = 0; i < bytesRead; i += 1) if (buffer[i] === 10) count += 1;
+				offset += bytesRead;
+			}
+			return count;
+		} finally {
+			await handle.close();
+		}
+	}
+	resetSessionDelta(absPath, size) {
+		const state = this.sessionDeltas.get(absPath);
+		if (!state) return;
+		state.lastSize = size;
+		state.pendingBytes = 0;
+		state.pendingMessages = 0;
+	}
+	isSessionFileForAgent(sessionFile) {
+		if (!sessionFile) return false;
+		const sessionsDir = resolveSessionTranscriptsDirForAgent(this.agentId);
+		const resolvedFile = path.resolve(sessionFile);
+		const resolvedDir = path.resolve(sessionsDir);
+		return resolvedFile.startsWith(`${resolvedDir}${path.sep}`);
+	}
+	normalizeTargetSessionFiles(sessionFiles) {
+		if (!sessionFiles || sessionFiles.length === 0) return null;
+		const normalized = /* @__PURE__ */ new Set();
+		for (const sessionFile of sessionFiles) {
+			const trimmed = sessionFile.trim();
+			if (!trimmed) continue;
+			const resolved = path.resolve(trimmed);
+			if (this.isSessionFileForAgent(resolved)) normalized.add(resolved);
+		}
+		return normalized.size > 0 ? normalized : null;
+	}
+	clearSyncedSessionFiles(targetSessionFiles) {
+		if (!targetSessionFiles) this.sessionsDirtyFiles.clear();
+		else for (const targetSessionFile of targetSessionFiles) this.sessionsDirtyFiles.delete(targetSessionFile);
+		this.sessionsDirty = this.sessionsDirtyFiles.size > 0;
+	}
+	ensureIntervalSync() {
+		const minutes = this.settings.sync.intervalMinutes;
+		if (!minutes || minutes <= 0 || this.intervalTimer) return;
+		const ms = minutes * 60 * 1e3;
+		this.intervalTimer = setInterval(() => {
+			runDetachedMemorySync(() => this.sync({ reason: "interval" }), "interval");
+		}, ms);
+	}
+	scheduleWatchSync() {
+		if (!this.sources.has("memory") || !this.settings.sync.watch) return;
+		if (this.watchTimer) clearTimeout(this.watchTimer);
+		this.watchTimer = setTimeout(() => {
+			this.watchTimer = null;
+			runDetachedMemorySync(() => this.sync({ reason: "watch" }), "watch");
+		}, this.settings.sync.watchDebounceMs);
+	}
+	shouldSyncSessions(params, needsFullReindex = false) {
+		if (!this.sources.has("sessions")) return false;
+		if (params?.sessionFiles?.some((sessionFile) => sessionFile.trim().length > 0)) return true;
+		if (params?.force) return true;
+		const reason = params?.reason;
+		if (reason === "session-start" || reason === "watch") return false;
+		if (needsFullReindex) return true;
+		return this.sessionsDirty && this.sessionsDirtyFiles.size > 0;
+	}
+	async syncMemoryFiles(params) {
+		if (!this.provider) {
+			log$2.debug("Skipping memory file sync in FTS-only mode (no embedding provider)");
+			return;
+		}
+		const fileEntries = (await runWithConcurrency((await listMemoryFiles(this.workspaceDir, this.settings.extraPaths, this.settings.multimodal)).map((file) => async () => await buildFileEntry(file, this.workspaceDir, this.settings.multimodal)), this.getIndexConcurrency())).filter((entry) => entry !== null);
+		log$2.debug("memory sync: indexing memory files", {
+			files: fileEntries.length,
+			needsFullReindex: params.needsFullReindex,
+			batch: this.batch.enabled,
+			concurrency: this.getIndexConcurrency()
+		});
+		const activePaths = new Set(fileEntries.map((entry) => entry.path));
+		if (params.progress) {
+			params.progress.total += fileEntries.length;
+			params.progress.report({
+				completed: params.progress.completed,
+				total: params.progress.total,
+				label: this.batch.enabled ? "Indexing memory files (batch)..." : "Indexing memory files…"
+			});
+		}
+		await runWithConcurrency(fileEntries.map((entry) => async () => {
+			const record = this.db.prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`).get(entry.path, "memory");
+			if (!params.needsFullReindex && record?.hash === entry.hash) {
+				if (params.progress) {
+					params.progress.completed += 1;
+					params.progress.report({
+						completed: params.progress.completed,
+						total: params.progress.total
+					});
+				}
+				return;
+			}
+			await this.indexFile(entry, { source: "memory" });
+			if (params.progress) {
+				params.progress.completed += 1;
+				params.progress.report({
+					completed: params.progress.completed,
+					total: params.progress.total
+				});
+			}
+		}), this.getIndexConcurrency());
+		const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("memory");
+		for (const stale of staleRows) {
+			if (activePaths.has(stale.path)) continue;
+			this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "memory");
+			try {
+				this.db.prepare(`DELETE FROM ${VECTOR_TABLE$2} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`).run(stale.path, "memory");
+			} catch {}
+			this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(stale.path, "memory");
+			if (this.fts.enabled && this.fts.available) try {
+				this.db.prepare(`DELETE FROM ${FTS_TABLE$2} WHERE path = ? AND source = ? AND model = ?`).run(stale.path, "memory", this.provider.model);
+			} catch {}
+		}
+	}
+	async syncSessionFiles(params) {
+		if (!this.provider) {
+			log$2.debug("Skipping session file sync in FTS-only mode (no embedding provider)");
+			return;
+		}
+		const targetSessionFiles = params.needsFullReindex ? null : this.normalizeTargetSessionFiles(params.targetSessionFiles);
+		const files = targetSessionFiles ? Array.from(targetSessionFiles) : await listSessionFilesForAgent(this.agentId);
+		const activePaths = targetSessionFiles ? null : new Set(files.map((file) => sessionPathForFile(file)));
+		const indexAll = params.needsFullReindex || Boolean(targetSessionFiles) || this.sessionsDirtyFiles.size === 0;
+		log$2.debug("memory sync: indexing session files", {
+			files: files.length,
+			indexAll,
+			dirtyFiles: this.sessionsDirtyFiles.size,
+			targetedFiles: targetSessionFiles?.size ?? 0,
+			batch: this.batch.enabled,
+			concurrency: this.getIndexConcurrency()
+		});
+		if (params.progress) {
+			params.progress.total += files.length;
+			params.progress.report({
+				completed: params.progress.completed,
+				total: params.progress.total,
+				label: this.batch.enabled ? "Indexing session files (batch)..." : "Indexing session files…"
+			});
+		}
+		await runWithConcurrency(files.map((absPath) => async () => {
+			if (!indexAll && !this.sessionsDirtyFiles.has(absPath)) {
+				if (params.progress) {
+					params.progress.completed += 1;
+					params.progress.report({
+						completed: params.progress.completed,
+						total: params.progress.total
+					});
+				}
+				return;
+			}
+			const entry = await buildSessionEntry(absPath);
+			if (!entry) {
+				if (params.progress) {
+					params.progress.completed += 1;
+					params.progress.report({
+						completed: params.progress.completed,
+						total: params.progress.total
+					});
+				}
+				return;
+			}
+			const record = this.db.prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`).get(entry.path, "sessions");
+			if (!params.needsFullReindex && record?.hash === entry.hash) {
+				if (params.progress) {
+					params.progress.completed += 1;
+					params.progress.report({
+						completed: params.progress.completed,
+						total: params.progress.total
+					});
+				}
+				this.resetSessionDelta(absPath, entry.size);
+				return;
+			}
+			await this.indexFile(entry, {
+				source: "sessions",
+				content: entry.content
+			});
+			this.resetSessionDelta(absPath, entry.size);
+			if (params.progress) {
+				params.progress.completed += 1;
+				params.progress.report({
+					completed: params.progress.completed,
+					total: params.progress.total
+				});
+			}
+		}), this.getIndexConcurrency());
+		if (activePaths === null) return;
+		const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("sessions");
+		for (const stale of staleRows) {
+			if (activePaths.has(stale.path)) continue;
+			this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "sessions");
+			try {
+				this.db.prepare(`DELETE FROM ${VECTOR_TABLE$2} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`).run(stale.path, "sessions");
+			} catch {}
+			this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(stale.path, "sessions");
+			if (this.fts.enabled && this.fts.available) try {
+				this.db.prepare(`DELETE FROM ${FTS_TABLE$2} WHERE path = ? AND source = ? AND model = ?`).run(stale.path, "sessions", this.provider.model);
+			} catch {}
+		}
+	}
+	createSyncProgress(onProgress) {
+		const state = {
+			completed: 0,
+			total: 0,
+			label: void 0,
+			report: (update) => {
+				if (update.label) state.label = update.label;
+				const label = update.total > 0 && state.label ? `${state.label} ${update.completed}/${update.total}` : state.label;
+				onProgress({
+					completed: update.completed,
+					total: update.total,
+					label
+				});
+			}
+		};
+		return state;
+	}
+	async runSync(params) {
+		const progress = params?.progress ? this.createSyncProgress(params.progress) : void 0;
+		if (progress) progress.report({
+			completed: progress.completed,
+			total: progress.total,
+			label: "Loading vector extension…"
+		});
+		const vectorReady = await this.ensureVectorReady();
+		const meta = this.readMeta();
+		const configuredSources = this.resolveConfiguredSourcesForMeta();
+		const configuredScopeHash = this.resolveConfiguredScopeHash();
+		const targetSessionFiles = this.normalizeTargetSessionFiles(params?.sessionFiles);
+		const hasTargetSessionFiles = targetSessionFiles !== null;
+		if (hasTargetSessionFiles && targetSessionFiles && this.sources.has("sessions")) {
+			try {
+				await this.syncSessionFiles({
+					needsFullReindex: false,
+					targetSessionFiles: Array.from(targetSessionFiles),
+					progress: progress ?? void 0
+				});
+				this.clearSyncedSessionFiles(targetSessionFiles);
+			} catch (err) {
+				const reason = err instanceof Error ? err.message : String(err);
+				if (this.shouldFallbackOnError(reason) && await this.activateFallbackProvider(reason)) {
+					if (process.env.OPENCLAW_TEST_FAST === "1" && process.env.OPENCLAW_TEST_MEMORY_UNSAFE_REINDEX === "1") await this.runUnsafeReindex({
+						reason: params?.reason,
+						force: true,
+						progress: progress ?? void 0
+					});
+					else await this.runSafeReindex({
+						reason: params?.reason,
+						force: true,
+						progress: progress ?? void 0
+					});
+					return;
+				}
+				throw err;
+			}
+			return;
+		}
+		const needsFullReindex = params?.force && !hasTargetSessionFiles || !meta || this.provider && meta.model !== this.provider.model || this.provider && meta.provider !== this.provider.id || meta.providerKey !== this.providerKey || this.metaSourcesDiffer(meta, configuredSources) || meta.scopeHash !== configuredScopeHash || meta.chunkTokens !== this.settings.chunking.tokens || meta.chunkOverlap !== this.settings.chunking.overlap || vectorReady && !meta?.vectorDims;
+		try {
+			if (needsFullReindex) {
+				if (process.env.OPENCLAW_TEST_FAST === "1" && process.env.OPENCLAW_TEST_MEMORY_UNSAFE_REINDEX === "1") await this.runUnsafeReindex({
+					reason: params?.reason,
+					force: params?.force,
+					progress: progress ?? void 0
+				});
+				else await this.runSafeReindex({
+					reason: params?.reason,
+					force: params?.force,
+					progress: progress ?? void 0
+				});
+				return;
+			}
+			const shouldSyncMemory = this.sources.has("memory") && (!hasTargetSessionFiles && params?.force || needsFullReindex || this.dirty);
+			const shouldSyncSessions = this.shouldSyncSessions(params, needsFullReindex);
+			if (shouldSyncMemory) {
+				await this.syncMemoryFiles({
+					needsFullReindex,
+					progress: progress ?? void 0
+				});
+				this.dirty = false;
+			}
+			if (shouldSyncSessions) {
+				await this.syncSessionFiles({
+					needsFullReindex,
+					targetSessionFiles: targetSessionFiles ? Array.from(targetSessionFiles) : void 0,
+					progress: progress ?? void 0
+				});
+				this.sessionsDirty = false;
+				this.sessionsDirtyFiles.clear();
+			} else if (this.sessionsDirtyFiles.size > 0) this.sessionsDirty = true;
+			else this.sessionsDirty = false;
+		} catch (err) {
+			const reason = err instanceof Error ? err.message : String(err);
+			if (this.shouldFallbackOnError(reason) && await this.activateFallbackProvider(reason)) {
+				await this.runSafeReindex({
+					reason: params?.reason ?? "fallback",
+					force: true,
+					progress: progress ?? void 0
+				});
+				return;
+			}
+			throw err;
+		}
+	}
+	shouldFallbackOnError(message) {
+		return /embedding|embeddings|batch/i.test(message);
+	}
+	resolveBatchConfig() {
+		const batch = this.settings.remote?.batch;
+		return {
+			enabled: Boolean(batch?.enabled && this.provider && (this.openAi && this.provider.id === "openai" || this.gemini && this.provider.id === "gemini" || this.voyage && this.provider.id === "voyage")),
+			wait: batch?.wait ?? true,
+			concurrency: Math.max(1, batch?.concurrency ?? 2),
+			pollIntervalMs: batch?.pollIntervalMs ?? 2e3,
+			timeoutMs: (batch?.timeoutMinutes ?? 60) * 60 * 1e3
+		};
+	}
+	async activateFallbackProvider(reason) {
+		const fallback = this.settings.fallback;
+		if (!fallback || fallback === "none" || !this.provider || fallback === this.provider.id) return false;
+		if (this.fallbackFrom) return false;
+		const fallbackFrom = this.provider.id;
+		const fallbackModel = fallback === "gemini" ? DEFAULT_GEMINI_EMBEDDING_MODEL : fallback === "openai" ? DEFAULT_OPENAI_EMBEDDING_MODEL : fallback === "voyage" ? DEFAULT_VOYAGE_EMBEDDING_MODEL : fallback === "mistral" ? DEFAULT_MISTRAL_EMBEDDING_MODEL : fallback === "ollama" ? DEFAULT_OLLAMA_EMBEDDING_MODEL : this.settings.model;
+		const fallbackResult = await createEmbeddingProvider({
+			config: this.cfg,
+			agentDir: resolveAgentDir(this.cfg, this.agentId),
+			provider: fallback,
+			remote: this.settings.remote,
+			model: fallbackModel,
+			outputDimensionality: this.settings.outputDimensionality,
+			fallback: "none",
+			local: this.settings.local
+		});
+		this.fallbackFrom = fallbackFrom;
+		this.fallbackReason = reason;
+		this.provider = fallbackResult.provider;
+		this.openAi = fallbackResult.openAi;
+		this.gemini = fallbackResult.gemini;
+		this.voyage = fallbackResult.voyage;
+		this.mistral = fallbackResult.mistral;
+		this.ollama = fallbackResult.ollama;
+		this.providerKey = this.computeProviderKey();
+		this.batch = this.resolveBatchConfig();
+		log$2.warn(`memory embeddings: switched to fallback provider (${fallback})`, { reason });
+		return true;
+	}
+	async runSafeReindex(params) {
+		const dbPath = resolveUserPath(this.settings.store.path);
+		const tempDbPath = `${dbPath}.tmp-${randomUUID()}`;
+		const tempDb = this.openDatabaseAtPath(tempDbPath);
+		const originalDb = this.db;
+		let originalDbClosed = false;
+		const originalState = {
+			ftsAvailable: this.fts.available,
+			ftsError: this.fts.loadError,
+			vectorAvailable: this.vector.available,
+			vectorLoadError: this.vector.loadError,
+			vectorDims: this.vector.dims,
+			vectorReady: this.vectorReady
+		};
+		const restoreOriginalState = () => {
+			if (originalDbClosed) this.db = this.openDatabaseAtPath(dbPath);
+			else this.db = originalDb;
+			this.fts.available = originalState.ftsAvailable;
+			this.fts.loadError = originalState.ftsError;
+			this.vector.available = originalDbClosed ? null : originalState.vectorAvailable;
+			this.vector.loadError = originalState.vectorLoadError;
+			this.vector.dims = originalState.vectorDims;
+			this.vectorReady = originalDbClosed ? null : originalState.vectorReady;
+		};
+		this.db = tempDb;
+		this.vectorReady = null;
+		this.vector.available = null;
+		this.vector.loadError = void 0;
+		this.vector.dims = void 0;
+		this.fts.available = false;
+		this.fts.loadError = void 0;
+		this.ensureSchema();
+		let nextMeta = null;
+		try {
+			this.seedEmbeddingCache(originalDb);
+			const shouldSyncMemory = this.sources.has("memory");
+			const shouldSyncSessions = this.shouldSyncSessions({
+				reason: params.reason,
+				force: params.force
+			}, true);
+			if (shouldSyncMemory) {
+				await this.syncMemoryFiles({
+					needsFullReindex: true,
+					progress: params.progress
+				});
+				this.dirty = false;
+			}
+			if (shouldSyncSessions) {
+				await this.syncSessionFiles({
+					needsFullReindex: true,
+					progress: params.progress
+				});
+				this.sessionsDirty = false;
+				this.sessionsDirtyFiles.clear();
+			} else if (this.sessionsDirtyFiles.size > 0) this.sessionsDirty = true;
+			else this.sessionsDirty = false;
+			nextMeta = {
+				model: this.provider?.model ?? "fts-only",
+				provider: this.provider?.id ?? "none",
+				providerKey: this.providerKey,
+				sources: this.resolveConfiguredSourcesForMeta(),
+				scopeHash: this.resolveConfiguredScopeHash(),
+				chunkTokens: this.settings.chunking.tokens,
+				chunkOverlap: this.settings.chunking.overlap
+			};
+			if (!nextMeta) throw new Error("Failed to compute memory index metadata for reindexing.");
+			if (this.vector.available && this.vector.dims) nextMeta.vectorDims = this.vector.dims;
+			this.writeMeta(nextMeta);
+			this.pruneEmbeddingCacheIfNeeded?.();
+			this.db.close();
+			originalDb.close();
+			originalDbClosed = true;
+			await this.swapIndexFiles(dbPath, tempDbPath);
+			this.db = this.openDatabaseAtPath(dbPath);
+			this.vectorReady = null;
+			this.vector.available = null;
+			this.vector.loadError = void 0;
+			this.ensureSchema();
+			this.vector.dims = nextMeta?.vectorDims;
+		} catch (err) {
+			try {
+				this.db.close();
+			} catch {}
+			await this.removeIndexFiles(tempDbPath);
+			restoreOriginalState();
+			throw err;
+		}
+	}
+	async runUnsafeReindex(params) {
+		this.resetIndex();
+		const shouldSyncMemory = this.sources.has("memory");
+		const shouldSyncSessions = this.shouldSyncSessions({
+			reason: params.reason,
+			force: params.force
+		}, true);
+		if (shouldSyncMemory) {
+			await this.syncMemoryFiles({
+				needsFullReindex: true,
+				progress: params.progress
+			});
+			this.dirty = false;
+		}
+		if (shouldSyncSessions) {
+			await this.syncSessionFiles({
+				needsFullReindex: true,
+				progress: params.progress
+			});
+			this.sessionsDirty = false;
+			this.sessionsDirtyFiles.clear();
+		} else if (this.sessionsDirtyFiles.size > 0) this.sessionsDirty = true;
+		else this.sessionsDirty = false;
+		const nextMeta = {
+			model: this.provider?.model ?? "fts-only",
+			provider: this.provider?.id ?? "none",
+			providerKey: this.providerKey,
+			sources: this.resolveConfiguredSourcesForMeta(),
+			scopeHash: this.resolveConfiguredScopeHash(),
+			chunkTokens: this.settings.chunking.tokens,
+			chunkOverlap: this.settings.chunking.overlap
+		};
+		if (this.vector.available && this.vector.dims) nextMeta.vectorDims = this.vector.dims;
+		this.writeMeta(nextMeta);
+		this.pruneEmbeddingCacheIfNeeded?.();
+	}
+	resetIndex() {
+		this.db.exec(`DELETE FROM files`);
+		this.db.exec(`DELETE FROM chunks`);
+		if (this.fts.enabled && this.fts.available) try {
+			this.db.exec(`DELETE FROM ${FTS_TABLE$2}`);
+		} catch {}
+		this.dropVectorTable();
+		this.vector.dims = void 0;
+		this.sessionsDirtyFiles.clear();
+	}
+	readMeta() {
+		const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY);
+		if (!row?.value) {
+			this.lastMetaSerialized = null;
+			return null;
+		}
+		try {
+			const parsed = JSON.parse(row.value);
+			this.lastMetaSerialized = row.value;
+			return parsed;
+		} catch {
+			this.lastMetaSerialized = null;
+			return null;
+		}
+	}
+	writeMeta(meta) {
+		const value = JSON.stringify(meta);
+		if (this.lastMetaSerialized === value) return;
+		this.db.prepare(`INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(META_KEY, value);
+		this.lastMetaSerialized = value;
+	}
+	resolveConfiguredSourcesForMeta() {
+		const normalized = Array.from(this.sources).filter((source) => source === "memory" || source === "sessions").toSorted();
+		return normalized.length > 0 ? normalized : ["memory"];
+	}
+	normalizeMetaSources(meta) {
+		if (!Array.isArray(meta.sources)) return ["memory"];
+		const normalized = Array.from(new Set(meta.sources.filter((source) => source === "memory" || source === "sessions"))).toSorted();
+		return normalized.length > 0 ? normalized : ["memory"];
+	}
+	resolveConfiguredScopeHash() {
+		const extraPaths = normalizeExtraMemoryPaths(this.workspaceDir, this.settings.extraPaths).map((value) => value.replace(/\\/g, "/")).toSorted();
+		return hashText(JSON.stringify({
+			extraPaths,
+			multimodal: {
+				enabled: this.settings.multimodal.enabled,
+				modalities: [...this.settings.multimodal.modalities].toSorted(),
+				maxFileBytes: this.settings.multimodal.maxFileBytes
+			}
+		}));
+	}
+	metaSourcesDiffer(meta, configuredSources) {
+		const metaSources = this.normalizeMetaSources(meta);
+		if (metaSources.length !== configuredSources.length) return true;
+		return metaSources.some((source, index) => source !== configuredSources[index]);
+	}
+};
+//#endregion
+//#region src/memory/manager-embedding-ops.ts
+const VECTOR_TABLE$1 = "chunks_vec";
+const FTS_TABLE$1 = "chunks_fts";
+const EMBEDDING_CACHE_TABLE$1 = "embedding_cache";
+const EMBEDDING_BATCH_MAX_TOKENS = 8e3;
+const EMBEDDING_INDEX_CONCURRENCY = 4;
+const EMBEDDING_RETRY_MAX_ATTEMPTS = 3;
+const EMBEDDING_RETRY_BASE_DELAY_MS = 500;
+const EMBEDDING_RETRY_MAX_DELAY_MS = 8e3;
+const BATCH_FAILURE_LIMIT$1 = 2;
+const EMBEDDING_QUERY_TIMEOUT_REMOTE_MS = 6e4;
+const EMBEDDING_QUERY_TIMEOUT_LOCAL_MS = 5 * 6e4;
+const EMBEDDING_BATCH_TIMEOUT_REMOTE_MS = 2 * 6e4;
+const EMBEDDING_BATCH_TIMEOUT_LOCAL_MS = 10 * 6e4;
+const vectorToBlob$1 = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
+const log$1 = createSubsystemLogger("memory");
+var MemoryManagerEmbeddingOps = class extends MemoryManagerSyncOps {
+	buildEmbeddingBatches(chunks) {
+		const batches = [];
+		let current = [];
+		let currentTokens = 0;
+		for (const chunk of chunks) {
+			const estimate = chunk.embeddingInput ? estimateStructuredEmbeddingInputBytes(chunk.embeddingInput) : estimateUtf8Bytes(chunk.text);
+			if (current.length > 0 && currentTokens + estimate > EMBEDDING_BATCH_MAX_TOKENS) {
+				batches.push(current);
+				current = [];
+				currentTokens = 0;
+			}
+			if (current.length === 0 && estimate > EMBEDDING_BATCH_MAX_TOKENS) {
+				batches.push([chunk]);
+				continue;
+			}
+			current.push(chunk);
+			currentTokens += estimate;
+		}
+		if (current.length > 0) batches.push(current);
+		return batches;
+	}
+	loadEmbeddingCache(hashes) {
+		if (!this.cache.enabled || !this.provider) return /* @__PURE__ */ new Map();
+		if (hashes.length === 0) return /* @__PURE__ */ new Map();
+		const unique = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const hash of hashes) {
+			if (!hash) continue;
+			if (seen.has(hash)) continue;
+			seen.add(hash);
+			unique.push(hash);
+		}
+		if (unique.length === 0) return /* @__PURE__ */ new Map();
+		const out = /* @__PURE__ */ new Map();
+		const baseParams = [
+			this.provider.id,
+			this.provider.model,
+			this.providerKey
+		];
+		const batchSize = 400;
+		for (let start = 0; start < unique.length; start += batchSize) {
+			const batch = unique.slice(start, start + batchSize);
+			const placeholders = batch.map(() => "?").join(", ");
+			const rows = this.db.prepare(`SELECT hash, embedding FROM ${EMBEDDING_CACHE_TABLE$1}\n WHERE provider = ? AND model = ? AND provider_key = ? AND hash IN (${placeholders})`).all(...baseParams, ...batch);
+			for (const row of rows) out.set(row.hash, parseEmbedding(row.embedding));
+		}
+		return out;
+	}
+	upsertEmbeddingCache(entries) {
+		if (!this.cache.enabled || !this.provider) return;
+		if (entries.length === 0) return;
+		const now = Date.now();
+		const stmt = this.db.prepare(`INSERT INTO ${EMBEDDING_CACHE_TABLE$1} (provider, model, provider_key, hash, embedding, dims, updated_at)\n VALUES (?, ?, ?, ?, ?, ?, ?)\n ON CONFLICT(provider, model, provider_key, hash) DO UPDATE SET\n   embedding=excluded.embedding,\n   dims=excluded.dims,\n   updated_at=excluded.updated_at`);
+		for (const entry of entries) {
+			const embedding = entry.embedding ?? [];
+			stmt.run(this.provider.id, this.provider.model, this.providerKey, entry.hash, JSON.stringify(embedding), embedding.length, now);
+		}
+	}
+	pruneEmbeddingCacheIfNeeded() {
+		if (!this.cache.enabled) return;
+		const max = this.cache.maxEntries;
+		if (!max || max <= 0) return;
+		const count = this.db.prepare(`SELECT COUNT(*) as c FROM ${EMBEDDING_CACHE_TABLE$1}`).get()?.c ?? 0;
+		if (count <= max) return;
+		const excess = count - max;
+		this.db.prepare(`DELETE FROM ${EMBEDDING_CACHE_TABLE$1}\n WHERE rowid IN (\n   SELECT rowid FROM ${EMBEDDING_CACHE_TABLE$1}\n   ORDER BY updated_at ASC\n   LIMIT ?\n )`).run(excess);
+	}
+	async embedChunksInBatches(chunks) {
+		if (chunks.length === 0) return [];
+		const { embeddings, missing } = this.collectCachedEmbeddings(chunks);
+		if (missing.length === 0) return embeddings;
+		const missingChunks = missing.map((m) => m.chunk);
+		const batches = this.buildEmbeddingBatches(missingChunks);
+		const toCache = [];
+		const provider = this.provider;
+		if (!provider) throw new Error("Cannot embed batch in FTS-only mode (no embedding provider)");
+		let cursor = 0;
+		for (const batch of batches) {
+			const inputs = batch.map((chunk) => chunk.embeddingInput ?? { text: chunk.text });
+			const hasStructuredInputs = inputs.some((input) => hasNonTextEmbeddingParts(input));
+			if (hasStructuredInputs && !provider.embedBatchInputs) throw new Error(`Embedding provider "${provider.id}" does not support multimodal memory inputs.`);
+			const batchEmbeddings = hasStructuredInputs ? await this.embedBatchInputsWithRetry(inputs) : await this.embedBatchWithRetry(batch.map((chunk) => chunk.text));
+			for (let i = 0; i < batch.length; i += 1) {
+				const item = missing[cursor + i];
+				const embedding = batchEmbeddings[i] ?? [];
+				if (item) {
+					embeddings[item.index] = embedding;
+					toCache.push({
+						hash: item.chunk.hash,
+						embedding
+					});
+				}
+			}
+			cursor += batch.length;
+		}
+		this.upsertEmbeddingCache(toCache);
+		return embeddings;
+	}
+	computeProviderKey() {
+		if (!this.provider) return hashText(JSON.stringify({
+			provider: "none",
+			model: "fts-only"
+		}));
+		if (this.provider.id === "openai" && this.openAi) {
+			const entries = Object.entries(this.openAi.headers).filter(([key]) => key.toLowerCase() !== "authorization").toSorted(([a], [b]) => a.localeCompare(b)).map(([key, value]) => [key, value]);
+			return hashText(JSON.stringify({
+				provider: "openai",
+				baseUrl: this.openAi.baseUrl,
+				model: this.openAi.model,
+				headers: entries
+			}));
+		}
+		if (this.provider.id === "gemini" && this.gemini) {
+			const entries = Object.entries(this.gemini.headers).filter(([key]) => {
+				const lower = key.toLowerCase();
+				return lower !== "authorization" && lower !== "x-goog-api-key";
+			}).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, value]) => [key, value]);
+			return hashText(JSON.stringify({
+				provider: "gemini",
+				baseUrl: this.gemini.baseUrl,
+				model: this.gemini.model,
+				outputDimensionality: this.gemini.outputDimensionality,
+				headers: entries
+			}));
+		}
+		return hashText(JSON.stringify({
+			provider: this.provider.id,
+			model: this.provider.model
+		}));
+	}
+	async embedChunksWithBatch(chunks, entry, source) {
+		if (!this.provider) return this.embedChunksInBatches(chunks);
+		if (this.provider.id === "openai" && this.openAi) return this.embedChunksWithOpenAiBatch(chunks, entry, source);
+		if (this.provider.id === "gemini" && this.gemini) return this.embedChunksWithGeminiBatch(chunks, entry, source);
+		if (this.provider.id === "voyage" && this.voyage) return this.embedChunksWithVoyageBatch(chunks, entry, source);
+		return this.embedChunksInBatches(chunks);
+	}
+	collectCachedEmbeddings(chunks) {
+		const cached = this.loadEmbeddingCache(chunks.map((chunk) => chunk.hash));
+		const embeddings = Array.from({ length: chunks.length }, () => []);
+		const missing = [];
+		for (let i = 0; i < chunks.length; i += 1) {
+			const chunk = chunks[i];
+			const hit = chunk?.hash ? cached.get(chunk.hash) : void 0;
+			if (hit && hit.length > 0) embeddings[i] = hit;
+			else if (chunk) missing.push({
+				index: i,
+				chunk
+			});
+		}
+		return {
+			embeddings,
+			missing
+		};
+	}
+	buildBatchCustomId(params) {
+		return hashText(`${params.source}:${params.entry.path}:${params.chunk.startLine}:${params.chunk.endLine}:${params.chunk.hash}:${params.index}`);
+	}
+	buildBatchRequests(params) {
+		const requests = [];
+		const mapping = /* @__PURE__ */ new Map();
+		for (const item of params.missing) {
+			const chunk = item.chunk;
+			const customId = this.buildBatchCustomId({
+				source: params.source,
+				entry: params.entry,
+				chunk,
+				index: item.index
+			});
+			mapping.set(customId, {
+				index: item.index,
+				hash: chunk.hash
+			});
+			const built = params.build(chunk);
+			requests.push({
+				custom_id: customId,
+				...built
+			});
+		}
+		return {
+			requests,
+			mapping
+		};
+	}
+	applyBatchEmbeddings(params) {
+		const toCache = [];
+		for (const [customId, embedding] of params.byCustomId.entries()) {
+			const mapped = params.mapping.get(customId);
+			if (!mapped) continue;
+			params.embeddings[mapped.index] = embedding;
+			toCache.push({
+				hash: mapped.hash,
+				embedding
+			});
+		}
+		this.upsertEmbeddingCache(toCache);
+	}
+	buildEmbeddingBatchRunnerOptions(params) {
+		const { requests, chunks, source } = params;
+		return {
+			agentId: this.agentId,
+			requests,
+			wait: this.batch.wait,
+			concurrency: this.batch.concurrency,
+			pollIntervalMs: this.batch.pollIntervalMs,
+			timeoutMs: this.batch.timeoutMs,
+			debug: (message, data) => log$1.debug(message, data ? {
+				...data,
+				source,
+				chunks: chunks.length
+			} : {
+				source,
+				chunks: chunks.length
+			})
+		};
+	}
+	async embedChunksWithProviderBatch(params) {
+		if (!params.enabled) return this.embedChunksInBatches(params.chunks);
+		if (params.chunks.length === 0) return [];
+		const { embeddings, missing } = this.collectCachedEmbeddings(params.chunks);
+		if (missing.length === 0) return embeddings;
+		const { requests, mapping } = this.buildBatchRequests({
+			missing,
+			entry: params.entry,
+			source: params.source,
+			build: params.buildRequest
+		});
+		const runnerOptions = this.buildEmbeddingBatchRunnerOptions({
+			requests,
+			chunks: params.chunks,
+			source: params.source
+		});
+		const batchResult = await this.runBatchWithFallback({
+			provider: params.provider,
+			run: async () => await params.runBatch(runnerOptions),
+			fallback: async () => await this.embedChunksInBatches(params.chunks)
+		});
+		if (Array.isArray(batchResult)) return batchResult;
+		this.applyBatchEmbeddings({
+			byCustomId: batchResult,
+			mapping,
+			embeddings
+		});
+		return embeddings;
+	}
+	async embedChunksWithVoyageBatch(chunks, entry, source) {
+		const voyage = this.voyage;
+		return await this.embedChunksWithProviderBatch({
+			chunks,
+			entry,
+			source,
+			provider: "voyage",
+			enabled: Boolean(voyage),
+			buildRequest: (chunk) => ({ body: { input: chunk.text } }),
+			runBatch: async (runnerOptions) => await runVoyageEmbeddingBatches({
+				client: voyage,
+				...runnerOptions
+			})
+		});
+	}
+	async embedChunksWithOpenAiBatch(chunks, entry, source) {
+		const openAi = this.openAi;
+		return await this.embedChunksWithProviderBatch({
+			chunks,
+			entry,
+			source,
+			provider: "openai",
+			enabled: Boolean(openAi),
+			buildRequest: (chunk) => ({
+				method: "POST",
+				url: OPENAI_BATCH_ENDPOINT,
+				body: {
+					model: openAi?.model ?? this.provider?.model ?? "text-embedding-3-small",
+					input: chunk.text
+				}
+			}),
+			runBatch: async (runnerOptions) => await runOpenAiEmbeddingBatches({
+				openAi,
+				...runnerOptions
+			})
+		});
+	}
+	async embedChunksWithGeminiBatch(chunks, entry, source) {
+		const gemini = this.gemini;
+		if (chunks.some((chunk) => hasNonTextEmbeddingParts(chunk.embeddingInput))) return await this.embedChunksInBatches(chunks);
+		return await this.embedChunksWithProviderBatch({
+			chunks,
+			entry,
+			source,
+			provider: "gemini",
+			enabled: Boolean(gemini),
+			buildRequest: (chunk) => ({ request: buildGeminiEmbeddingRequest({
+				input: chunk.embeddingInput ?? { text: chunk.text },
+				taskType: "RETRIEVAL_DOCUMENT",
+				modelPath: this.gemini?.modelPath,
+				outputDimensionality: this.gemini?.outputDimensionality
+			}) }),
+			runBatch: async (runnerOptions) => await runGeminiEmbeddingBatches({
+				gemini,
+				...runnerOptions
+			})
+		});
+	}
+	async embedBatchWithRetry(texts) {
+		if (texts.length === 0) return [];
+		if (!this.provider) throw new Error("Cannot embed batch in FTS-only mode (no embedding provider)");
+		let attempt = 0;
+		let delayMs = EMBEDDING_RETRY_BASE_DELAY_MS;
+		while (true) try {
+			const timeoutMs = this.resolveEmbeddingTimeout("batch");
+			log$1.debug("memory embeddings: batch start", {
+				provider: this.provider.id,
+				items: texts.length,
+				timeoutMs
+			});
+			return await this.withTimeout(this.provider.embedBatch(texts), timeoutMs, `memory embeddings batch timed out after ${Math.round(timeoutMs / 1e3)}s`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (!this.isRetryableEmbeddingError(message) || attempt >= EMBEDDING_RETRY_MAX_ATTEMPTS) throw err;
+			await this.waitForEmbeddingRetry(delayMs, "retrying");
+			delayMs *= 2;
+			attempt += 1;
+		}
+	}
+	async embedBatchInputsWithRetry(inputs) {
+		if (inputs.length === 0) return [];
+		if (!this.provider?.embedBatchInputs) return await this.embedBatchWithRetry(inputs.map((input) => input.text));
+		let attempt = 0;
+		let delayMs = EMBEDDING_RETRY_BASE_DELAY_MS;
+		while (true) try {
+			const timeoutMs = this.resolveEmbeddingTimeout("batch");
+			log$1.debug("memory embeddings: structured batch start", {
+				provider: this.provider.id,
+				items: inputs.length,
+				timeoutMs
+			});
+			return await this.withTimeout(this.provider.embedBatchInputs(inputs), timeoutMs, `memory embeddings batch timed out after ${Math.round(timeoutMs / 1e3)}s`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (!this.isRetryableEmbeddingError(message) || attempt >= EMBEDDING_RETRY_MAX_ATTEMPTS) throw err;
+			await this.waitForEmbeddingRetry(delayMs, "retrying structured batch");
+			delayMs *= 2;
+			attempt += 1;
+		}
+	}
+	async waitForEmbeddingRetry(delayMs, action) {
+		const waitMs = Math.min(EMBEDDING_RETRY_MAX_DELAY_MS, Math.round(delayMs * (1 + Math.random() * .2)));
+		log$1.warn(`memory embeddings rate limited; ${action} in ${waitMs}ms`);
+		await new Promise((resolve) => setTimeout(resolve, waitMs));
+	}
+	isRetryableEmbeddingError(message) {
+		return /(rate[_ ]limit|too many requests|429|resource has been exhausted|5\d\d|cloudflare|tokens per day)/i.test(message);
+	}
+	resolveEmbeddingTimeout(kind) {
+		const isLocal = this.provider?.id === "local";
+		if (kind === "query") return isLocal ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS;
+		return isLocal ? EMBEDDING_BATCH_TIMEOUT_LOCAL_MS : EMBEDDING_BATCH_TIMEOUT_REMOTE_MS;
+	}
+	async embedQueryWithTimeout(text) {
+		if (!this.provider) throw new Error("Cannot embed query in FTS-only mode (no embedding provider)");
+		const timeoutMs = this.resolveEmbeddingTimeout("query");
+		log$1.debug("memory embeddings: query start", {
+			provider: this.provider.id,
+			timeoutMs
+		});
+		return await this.withTimeout(this.provider.embedQuery(text), timeoutMs, `memory embeddings query timed out after ${Math.round(timeoutMs / 1e3)}s`);
+	}
+	async withTimeout(promise, timeoutMs, message) {
+		if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return await promise;
+		let timer = null;
+		const timeoutPromise = new Promise((_, reject) => {
+			timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+		});
+		try {
+			return await Promise.race([promise, timeoutPromise]);
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
+	}
+	async withBatchFailureLock(fn) {
+		let release;
+		const wait = this.batchFailureLock;
+		this.batchFailureLock = new Promise((resolve) => {
+			release = resolve;
+		});
+		await wait;
+		try {
+			return await fn();
+		} finally {
+			release();
+		}
+	}
+	async resetBatchFailureCount() {
+		await this.withBatchFailureLock(async () => {
+			if (this.batchFailureCount > 0) log$1.debug("memory embeddings: batch recovered; resetting failure count");
+			this.batchFailureCount = 0;
+			this.batchFailureLastError = void 0;
+			this.batchFailureLastProvider = void 0;
+		});
+	}
+	async recordBatchFailure(params) {
+		return await this.withBatchFailureLock(async () => {
+			if (!this.batch.enabled) return {
+				disabled: true,
+				count: this.batchFailureCount
+			};
+			const increment = params.forceDisable ? BATCH_FAILURE_LIMIT$1 : Math.max(1, params.attempts ?? 1);
+			this.batchFailureCount += increment;
+			this.batchFailureLastError = params.message;
+			this.batchFailureLastProvider = params.provider;
+			const disabled = params.forceDisable || this.batchFailureCount >= BATCH_FAILURE_LIMIT$1;
+			if (disabled) this.batch.enabled = false;
+			return {
+				disabled,
+				count: this.batchFailureCount
+			};
+		});
+	}
+	isBatchTimeoutError(message) {
+		return /timed out|timeout/i.test(message);
+	}
+	async runBatchWithTimeoutRetry(params) {
+		try {
+			return await params.run();
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (this.isBatchTimeoutError(message)) {
+				log$1.warn(`memory embeddings: ${params.provider} batch timed out; retrying once`);
+				try {
+					return await params.run();
+				} catch (retryErr) {
+					retryErr.batchAttempts = 2;
+					throw retryErr;
+				}
+			}
+			throw err;
+		}
+	}
+	async runBatchWithFallback(params) {
+		if (!this.batch.enabled) return await params.fallback();
+		try {
+			const result = await this.runBatchWithTimeoutRetry({
+				provider: params.provider,
+				run: params.run
+			});
+			await this.resetBatchFailureCount();
+			return result;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			const attempts = err.batchAttempts ?? 1;
+			const forceDisable = /asyncBatchEmbedContent not available/i.test(message);
+			const failure = await this.recordBatchFailure({
+				provider: params.provider,
+				message,
+				attempts,
+				forceDisable
+			});
+			const suffix = failure.disabled ? "disabling batch" : "keeping batch enabled";
+			log$1.warn(`memory embeddings: ${params.provider} batch failed (${failure.count}/${BATCH_FAILURE_LIMIT$1}); ${suffix}; falling back to non-batch embeddings: ${message}`);
+			return await params.fallback();
+		}
+	}
+	getIndexConcurrency() {
+		return this.batch.enabled ? this.batch.concurrency : EMBEDDING_INDEX_CONCURRENCY;
+	}
+	clearIndexedFileData(pathname, source) {
+		if (this.vector.enabled) try {
+			this.db.prepare(`DELETE FROM ${VECTOR_TABLE$1} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`).run(pathname, source);
+		} catch {}
+		if (this.fts.enabled && this.fts.available && this.provider) try {
+			this.db.prepare(`DELETE FROM ${FTS_TABLE$1} WHERE path = ? AND source = ? AND model = ?`).run(pathname, source, this.provider.model);
+		} catch {}
+		this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(pathname, source);
+	}
+	upsertFileRecord(entry, source) {
+		this.db.prepare(`INSERT INTO files (path, source, hash, mtime, size) VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET
+           source=excluded.source,
+           hash=excluded.hash,
+           mtime=excluded.mtime,
+           size=excluded.size`).run(entry.path, source, entry.hash, entry.mtimeMs, entry.size);
+	}
+	deleteFileRecord(pathname, source) {
+		this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(pathname, source);
+	}
+	isStructuredInputTooLargeError(message) {
+		return /(413|payload too large|request too large|input too large|too many tokens|input limit|request size)/i.test(message);
+	}
+	async indexFile(entry, options) {
+		if (!this.provider) {
+			log$1.debug("Skipping embedding indexing in FTS-only mode", {
+				path: entry.path,
+				source: options.source
+			});
+			return;
+		}
+		let chunks;
+		let structuredInputBytes;
+		if ("kind" in entry && entry.kind === "multimodal") {
+			const multimodalChunk = await buildMultimodalChunkForIndexing(entry);
+			if (!multimodalChunk) {
+				this.clearIndexedFileData(entry.path, options.source);
+				this.deleteFileRecord(entry.path, options.source);
+				return;
+			}
+			structuredInputBytes = multimodalChunk.structuredInputBytes;
+			chunks = [multimodalChunk.chunk];
+		} else {
+			const content = options.content ?? await fs$1.readFile(entry.absPath, "utf-8");
+			chunks = enforceEmbeddingMaxInputTokens(this.provider, chunkMarkdown(content, this.settings.chunking).filter((chunk) => chunk.text.trim().length > 0), EMBEDDING_BATCH_MAX_TOKENS);
+			if (options.source === "sessions" && "lineMap" in entry) remapChunkLines(chunks, entry.lineMap);
+		}
+		let embeddings;
+		try {
+			embeddings = this.batch.enabled ? await this.embedChunksWithBatch(chunks, entry, options.source) : await this.embedChunksInBatches(chunks);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if ("kind" in entry && entry.kind === "multimodal" && this.isStructuredInputTooLargeError(message)) {
+				log$1.warn("memory embeddings: skipping multimodal file rejected as too large", {
+					path: entry.path,
+					bytes: structuredInputBytes,
+					provider: this.provider.id,
+					model: this.provider.model,
+					error: message
+				});
+				this.clearIndexedFileData(entry.path, options.source);
+				this.upsertFileRecord(entry, options.source);
+				return;
+			}
+			throw err;
+		}
+		const sample = embeddings.find((embedding) => embedding.length > 0);
+		const vectorReady = sample ? await this.ensureVectorReady(sample.length) : false;
+		const now = Date.now();
+		this.clearIndexedFileData(entry.path, options.source);
+		for (let i = 0; i < chunks.length; i++) {
+			const chunk = chunks[i];
+			const embedding = embeddings[i] ?? [];
+			const id = hashText(`${options.source}:${entry.path}:${chunk.startLine}:${chunk.endLine}:${chunk.hash}:${this.provider.model}`);
+			this.db.prepare(`INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             hash=excluded.hash,
+             model=excluded.model,
+             text=excluded.text,
+             embedding=excluded.embedding,
+             updated_at=excluded.updated_at`).run(id, entry.path, options.source, chunk.startLine, chunk.endLine, chunk.hash, this.provider.model, chunk.text, JSON.stringify(embedding), now);
+			if (vectorReady && embedding.length > 0) {
+				try {
+					this.db.prepare(`DELETE FROM ${VECTOR_TABLE$1} WHERE id = ?`).run(id);
+				} catch {}
+				this.db.prepare(`INSERT INTO ${VECTOR_TABLE$1} (id, embedding) VALUES (?, ?)`).run(id, vectorToBlob$1(embedding));
+			}
+			if (this.fts.enabled && this.fts.available) this.db.prepare(`INSERT INTO ${FTS_TABLE$1} (text, id, path, source, model, start_line, end_line)\n VALUES (?, ?, ?, ?, ?, ?, ?)`).run(chunk.text, id, entry.path, options.source, this.provider.model, chunk.startLine, chunk.endLine);
+		}
+		this.upsertFileRecord(entry, options.source);
+	}
+};
+//#endregion
+//#region src/memory/manager-search.ts
+const vectorToBlob = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
+async function searchVector(params) {
+	if (params.queryVec.length === 0 || params.limit <= 0) return [];
+	if (await params.ensureVectorReady(params.queryVec.length)) return params.db.prepare(`SELECT c.id, c.path, c.start_line, c.end_line, c.text,
+       c.source,
+       vec_distance_cosine(v.embedding, ?) AS dist
+  FROM ${params.vectorTable} v\n  JOIN chunks c ON c.id = v.id\n WHERE c.model = ?${params.sourceFilterVec.sql}\n ORDER BY dist ASC\n LIMIT ?`).all(vectorToBlob(params.queryVec), params.providerModel, ...params.sourceFilterVec.params, params.limit).map((row) => ({
+		id: row.id,
+		path: row.path,
+		startLine: row.start_line,
+		endLine: row.end_line,
+		score: 1 - row.dist,
+		snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+		source: row.source
+	}));
+	return listChunks({
+		db: params.db,
+		providerModel: params.providerModel,
+		sourceFilter: params.sourceFilterChunks
+	}).map((chunk) => ({
+		chunk,
+		score: cosineSimilarity(params.queryVec, chunk.embedding)
+	})).filter((entry) => Number.isFinite(entry.score)).toSorted((a, b) => b.score - a.score).slice(0, params.limit).map((entry) => ({
+		id: entry.chunk.id,
+		path: entry.chunk.path,
+		startLine: entry.chunk.startLine,
+		endLine: entry.chunk.endLine,
+		score: entry.score,
+		snippet: truncateUtf16Safe(entry.chunk.text, params.snippetMaxChars),
+		source: entry.chunk.source
+	}));
+}
+function listChunks(params) {
+	return params.db.prepare(`SELECT id, path, start_line, end_line, text, embedding, source
+  FROM chunks
+ WHERE model = ?${params.sourceFilter.sql}`).all(params.providerModel, ...params.sourceFilter.params).map((row) => ({
+		id: row.id,
+		path: row.path,
+		startLine: row.start_line,
+		endLine: row.end_line,
+		text: row.text,
+		embedding: parseEmbedding(row.embedding),
+		source: row.source
+	}));
+}
+async function searchKeyword(params) {
+	if (params.limit <= 0) return [];
+	const ftsQuery = params.buildFtsQuery(params.query);
+	if (!ftsQuery) return [];
+	const modelClause = params.providerModel ? " AND model = ?" : "";
+	const modelParams = params.providerModel ? [params.providerModel] : [];
+	return params.db.prepare(`SELECT id, path, source, start_line, end_line, text,\n       bm25(${params.ftsTable}) AS rank\n  FROM ${params.ftsTable}\n WHERE ${params.ftsTable} MATCH ?${modelClause}${params.sourceFilter.sql}\n ORDER BY rank ASC\n LIMIT ?`).all(ftsQuery, ...modelParams, ...params.sourceFilter.params, params.limit).map((row) => {
+		const textScore = params.bm25RankToScore(row.rank);
+		return {
+			id: row.id,
+			path: row.path,
+			startLine: row.start_line,
+			endLine: row.end_line,
+			score: textScore,
+			textScore,
+			snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+			source: row.source
+		};
+	});
+}
+//#endregion
+//#region src/memory/read-file.ts
+async function readMemoryFile(params) {
+	const rawPath = params.relPath.trim();
+	if (!rawPath) throw new Error("path required");
+	const absPath = path.isAbsolute(rawPath) ? path.resolve(rawPath) : path.resolve(params.workspaceDir, rawPath);
+	const relPath = path.relative(params.workspaceDir, absPath).replace(/\\/g, "/");
+	const allowedWorkspace = relPath.length > 0 && !relPath.startsWith("..") && !path.isAbsolute(relPath) && isMemoryPath(relPath);
+	let allowedAdditional = false;
+	if (!allowedWorkspace && (params.extraPaths?.length ?? 0) > 0) {
+		const additionalPaths = normalizeExtraMemoryPaths(params.workspaceDir, params.extraPaths);
+		for (const additionalPath of additionalPaths) try {
+			const stat = await fs$1.lstat(additionalPath);
+			if (stat.isSymbolicLink()) continue;
+			if (stat.isDirectory()) {
+				if (absPath === additionalPath || absPath.startsWith(`${additionalPath}${path.sep}`)) {
+					allowedAdditional = true;
+					break;
+				}
+				continue;
+			}
+			if (stat.isFile() && absPath === additionalPath && absPath.endsWith(".md")) {
+				allowedAdditional = true;
+				break;
+			}
+		} catch {}
+	}
+	if (!allowedWorkspace && !allowedAdditional) throw new Error("path required");
+	if (!absPath.endsWith(".md")) throw new Error("path required");
+	if ((await statRegularFile(absPath)).missing) return {
+		text: "",
+		path: relPath
+	};
+	let content;
+	try {
+		content = await fs$1.readFile(absPath, "utf-8");
+	} catch (err) {
+		if (isFileMissingError(err)) return {
+			text: "",
+			path: relPath
+		};
+		throw err;
+	}
+	if (!params.from && !params.lines) return {
+		text: content,
+		path: relPath
+	};
+	const fileLines = content.split("\n");
+	const start = Math.max(1, params.from ?? 1);
+	const count = Math.max(1, params.lines ?? fileLines.length);
+	return {
+		text: fileLines.slice(start - 1, start - 1 + count).join("\n"),
+		path: relPath
+	};
+}
+async function readAgentMemoryFile(params) {
+	const settings = resolveMemorySearchConfig(params.cfg, params.agentId);
+	if (!settings) throw new Error("memory search disabled");
+	return await readMemoryFile({
+		workspaceDir: resolveAgentWorkspaceDir(params.cfg, params.agentId),
+		extraPaths: settings.extraPaths,
+		relPath: params.relPath,
+		from: params.from,
+		lines: params.lines
+	});
+}
+//#endregion
+//#region src/memory/manager.ts
+const SNIPPET_MAX_CHARS = 700;
+const VECTOR_TABLE = "chunks_vec";
+const FTS_TABLE = "chunks_fts";
+const EMBEDDING_CACHE_TABLE = "embedding_cache";
+const BATCH_FAILURE_LIMIT = 2;
+const MEMORY_INDEX_MANAGER_CACHE_KEY = "__openclawMemoryIndexManagerCache";
+function getMemoryIndexManagerCacheStore() {
+	const globalCache = globalThis;
+	globalCache[MEMORY_INDEX_MANAGER_CACHE_KEY] ??= {
+		indexCache: /* @__PURE__ */ new Map(),
+		indexCachePending: /* @__PURE__ */ new Map()
+	};
+	return globalCache[MEMORY_INDEX_MANAGER_CACHE_KEY];
+}
+const log = createSubsystemLogger("memory");
+const { indexCache: INDEX_CACHE, indexCachePending: INDEX_CACHE_PENDING } = getMemoryIndexManagerCacheStore();
+async function closeAllMemoryIndexManagers() {
+	const pending = Array.from(INDEX_CACHE_PENDING.values());
+	if (pending.length > 0) await Promise.allSettled(pending);
+	const managers = Array.from(INDEX_CACHE.values());
+	INDEX_CACHE.clear();
+	for (const manager of managers) try {
+		await manager.close();
+	} catch (err) {
+		log.warn(`failed to close memory index manager: ${String(err)}`);
+	}
+}
+var MemoryIndexManager = class MemoryIndexManager extends MemoryManagerEmbeddingOps {
+	static async loadProviderResult(params) {
+		return await createEmbeddingProvider({
+			config: params.cfg,
+			agentDir: resolveAgentDir(params.cfg, params.agentId),
+			provider: params.settings.provider,
+			remote: params.settings.remote,
+			model: params.settings.model,
+			outputDimensionality: params.settings.outputDimensionality,
+			fallback: params.settings.fallback,
+			local: params.settings.local
+		});
+	}
+	static async get(params) {
+		const { cfg, agentId } = params;
+		const settings = resolveMemorySearchConfig(cfg, agentId);
+		if (!settings) return null;
+		const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+		const purpose = params.purpose === "status" ? "status" : "default";
+		const key = `${agentId}:${workspaceDir}:${JSON.stringify(settings)}:${purpose}`;
+		const statusOnly = params.purpose === "status";
+		const existing = INDEX_CACHE.get(key);
+		if (existing) return existing;
+		const pending = INDEX_CACHE_PENDING.get(key);
+		if (pending) return pending;
+		if (statusOnly) {
+			const manager = new MemoryIndexManager({
+				cacheKey: key,
+				cfg,
+				agentId,
+				workspaceDir,
+				settings,
+				purpose: params.purpose
+			});
+			INDEX_CACHE.set(key, manager);
+			return manager;
+		}
+		const createPromise = (async () => {
+			const providerResult = await MemoryIndexManager.loadProviderResult({
+				cfg,
+				agentId,
+				settings
+			});
+			const refreshed = INDEX_CACHE.get(key);
+			if (refreshed) return refreshed;
+			const manager = new MemoryIndexManager({
+				cacheKey: key,
+				cfg,
+				agentId,
+				workspaceDir,
+				settings,
+				providerResult,
+				purpose: params.purpose
+			});
+			INDEX_CACHE.set(key, manager);
+			return manager;
+		})();
+		INDEX_CACHE_PENDING.set(key, createPromise);
+		try {
+			return await createPromise;
+		} finally {
+			if (INDEX_CACHE_PENDING.get(key) === createPromise) INDEX_CACHE_PENDING.delete(key);
+		}
+	}
+	constructor(params) {
+		super();
+		this.providerInitPromise = null;
+		this.providerInitialized = false;
+		this.batchFailureCount = 0;
+		this.batchFailureLock = Promise.resolve();
+		this.vectorReady = null;
+		this.watcher = null;
+		this.watchTimer = null;
+		this.sessionWatchTimer = null;
+		this.sessionUnsubscribe = null;
+		this.intervalTimer = null;
+		this.closed = false;
+		this.dirty = false;
+		this.sessionsDirty = false;
+		this.sessionsDirtyFiles = /* @__PURE__ */ new Set();
+		this.sessionPendingFiles = /* @__PURE__ */ new Set();
+		this.sessionDeltas = /* @__PURE__ */ new Map();
+		this.sessionWarm = /* @__PURE__ */ new Set();
+		this.syncing = null;
+		this.queuedSessionFiles = /* @__PURE__ */ new Set();
+		this.queuedSessionSync = null;
+		this.readonlyRecoveryAttempts = 0;
+		this.readonlyRecoverySuccesses = 0;
+		this.readonlyRecoveryFailures = 0;
+		this.cacheKey = params.cacheKey;
+		this.cfg = params.cfg;
+		this.agentId = params.agentId;
+		this.workspaceDir = params.workspaceDir;
+		this.settings = params.settings;
+		this.provider = null;
+		this.requestedProvider = params.settings.provider;
+		if (params.providerResult) this.applyProviderResult(params.providerResult);
+		this.sources = new Set(params.settings.sources);
+		this.db = this.openDatabase();
+		this.providerKey = this.computeProviderKey();
+		this.cache = {
+			enabled: params.settings.cache.enabled,
+			maxEntries: params.settings.cache.maxEntries
+		};
+		this.fts = {
+			enabled: params.settings.query.hybrid.enabled,
+			available: false
+		};
+		this.ensureSchema();
+		this.vector = {
+			enabled: params.settings.store.vector.enabled,
+			available: null,
+			extensionPath: params.settings.store.vector.extensionPath
+		};
+		const meta = this.readMeta();
+		if (meta?.vectorDims) this.vector.dims = meta.vectorDims;
+		const statusOnly = params.purpose === "status";
+		if (!statusOnly) {
+			this.ensureWatcher();
+			this.ensureSessionListener();
+			this.ensureIntervalSync();
+		}
+		this.dirty = this.sources.has("memory") && (statusOnly ? !meta : true);
+		this.batch = this.resolveBatchConfig();
+	}
+	applyProviderResult(providerResult) {
+		this.provider = providerResult.provider;
+		this.fallbackFrom = providerResult.fallbackFrom;
+		this.fallbackReason = providerResult.fallbackReason;
+		this.providerUnavailableReason = providerResult.providerUnavailableReason;
+		this.openAi = providerResult.openAi;
+		this.gemini = providerResult.gemini;
+		this.voyage = providerResult.voyage;
+		this.mistral = providerResult.mistral;
+		this.ollama = providerResult.ollama;
+		this.providerInitialized = true;
+	}
+	async ensureProviderInitialized() {
+		if (this.providerInitialized) return;
+		if (!this.providerInitPromise) this.providerInitPromise = (async () => {
+			const providerResult = await MemoryIndexManager.loadProviderResult({
+				cfg: this.cfg,
+				agentId: this.agentId,
+				settings: this.settings
+			});
+			this.applyProviderResult(providerResult);
+			this.providerKey = this.computeProviderKey();
+			this.batch = this.resolveBatchConfig();
+		})();
+		try {
+			await this.providerInitPromise;
+		} finally {
+			if (this.providerInitialized) this.providerInitPromise = null;
+		}
+	}
+	async warmSession(sessionKey) {
+		if (!this.settings.sync.onSessionStart) return;
+		const key = sessionKey?.trim() || "";
+		if (key && this.sessionWarm.has(key)) return;
+		this.sync({ reason: "session-start" }).catch((err) => {
+			log.warn(`memory sync failed (session-start): ${String(err)}`);
+		});
+		if (key) this.sessionWarm.add(key);
+	}
+	async search(query, opts) {
+		await this.ensureProviderInitialized();
+		this.warmSession(opts?.sessionKey);
+		if (this.settings.sync.onSearch && (this.dirty || this.sessionsDirty)) this.sync({ reason: "search" }).catch((err) => {
+			log.warn(`memory sync failed (search): ${String(err)}`);
+		});
+		const cleaned = query.trim();
+		if (!cleaned) return [];
+		const minScore = opts?.minScore ?? this.settings.query.minScore;
+		const maxResults = opts?.maxResults ?? this.settings.query.maxResults;
+		const hybrid = this.settings.query.hybrid;
+		const candidates = Math.min(200, Math.max(1, Math.floor(maxResults * hybrid.candidateMultiplier)));
+		if (!this.provider) {
+			if (!this.fts.enabled || !this.fts.available) {
+				log.warn("memory search: no provider and FTS unavailable");
+				return [];
+			}
+			const keywords = extractKeywords(cleaned);
+			const searchTerms = keywords.length > 0 ? keywords : [cleaned];
+			const resultSets = await Promise.all(searchTerms.map((term) => this.searchKeyword(term, candidates).catch(() => [])));
+			const seenIds = /* @__PURE__ */ new Map();
+			for (const results of resultSets) for (const result of results) {
+				const existing = seenIds.get(result.id);
+				if (!existing || result.score > existing.score) seenIds.set(result.id, result);
+			}
+			return [...seenIds.values()].toSorted((a, b) => b.score - a.score).filter((entry) => entry.score >= minScore).slice(0, maxResults);
+		}
+		const keywordResults = hybrid.enabled && this.fts.enabled && this.fts.available ? await this.searchKeyword(cleaned, candidates).catch(() => []) : [];
+		const queryVec = await this.embedQueryWithTimeout(cleaned);
+		const vectorResults = queryVec.some((v) => v !== 0) ? await this.searchVector(queryVec, candidates).catch(() => []) : [];
+		if (!hybrid.enabled || !this.fts.enabled || !this.fts.available) return vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults);
+		const merged = await this.mergeHybridResults({
+			vector: vectorResults,
+			keyword: keywordResults,
+			vectorWeight: hybrid.vectorWeight,
+			textWeight: hybrid.textWeight,
+			mmr: hybrid.mmr,
+			temporalDecay: hybrid.temporalDecay
+		});
+		const strict = merged.filter((entry) => entry.score >= minScore);
+		if (strict.length > 0 || keywordResults.length === 0) return strict.slice(0, maxResults);
+		const relaxedMinScore = Math.min(minScore, hybrid.textWeight);
+		const keywordKeys = new Set(keywordResults.map((entry) => `${entry.source}:${entry.path}:${entry.startLine}:${entry.endLine}`));
+		return merged.filter((entry) => keywordKeys.has(`${entry.source}:${entry.path}:${entry.startLine}:${entry.endLine}`) && entry.score >= relaxedMinScore).slice(0, maxResults);
+	}
+	async searchVector(queryVec, limit) {
+		if (!this.provider) return [];
+		return (await searchVector({
+			db: this.db,
+			vectorTable: VECTOR_TABLE,
+			providerModel: this.provider.model,
+			queryVec,
+			limit,
+			snippetMaxChars: SNIPPET_MAX_CHARS,
+			ensureVectorReady: async (dimensions) => await this.ensureVectorReady(dimensions),
+			sourceFilterVec: this.buildSourceFilter("c"),
+			sourceFilterChunks: this.buildSourceFilter()
+		})).map((entry) => entry);
+	}
+	buildFtsQuery(raw) {
+		return buildFtsQuery(raw);
+	}
+	async searchKeyword(query, limit) {
+		if (!this.fts.enabled || !this.fts.available) return [];
+		const sourceFilter = this.buildSourceFilter();
+		const providerModel = this.provider?.model;
+		return (await searchKeyword({
+			db: this.db,
+			ftsTable: FTS_TABLE,
+			providerModel,
+			query,
+			limit,
+			snippetMaxChars: SNIPPET_MAX_CHARS,
+			sourceFilter,
+			buildFtsQuery: (raw) => this.buildFtsQuery(raw),
+			bm25RankToScore
+		})).map((entry) => entry);
+	}
+	mergeHybridResults(params) {
+		return mergeHybridResults({
+			vector: params.vector.map((r) => ({
+				id: r.id,
+				path: r.path,
+				startLine: r.startLine,
+				endLine: r.endLine,
+				source: r.source,
+				snippet: r.snippet,
+				vectorScore: r.score
+			})),
+			keyword: params.keyword.map((r) => ({
+				id: r.id,
+				path: r.path,
+				startLine: r.startLine,
+				endLine: r.endLine,
+				source: r.source,
+				snippet: r.snippet,
+				textScore: r.textScore
+			})),
+			vectorWeight: params.vectorWeight,
+			textWeight: params.textWeight,
+			mmr: params.mmr,
+			temporalDecay: params.temporalDecay,
+			workspaceDir: this.workspaceDir
+		}).then((entries) => entries.map((entry) => entry));
+	}
+	async sync(params) {
+		if (this.closed) return;
+		await this.ensureProviderInitialized();
+		if (this.syncing) {
+			if (params?.sessionFiles?.some((sessionFile) => sessionFile.trim().length > 0)) return this.enqueueTargetedSessionSync(params.sessionFiles);
+			return this.syncing;
+		}
+		this.syncing = this.runSyncWithReadonlyRecovery(params).finally(() => {
+			this.syncing = null;
+		});
+		return this.syncing ?? Promise.resolve();
+	}
+	enqueueTargetedSessionSync(sessionFiles) {
+		for (const sessionFile of sessionFiles ?? []) {
+			const trimmed = sessionFile.trim();
+			if (trimmed) this.queuedSessionFiles.add(trimmed);
+		}
+		if (this.queuedSessionFiles.size === 0) return this.syncing ?? Promise.resolve();
+		if (!this.queuedSessionSync) this.queuedSessionSync = (async () => {
+			try {
+				await this.syncing?.catch(() => void 0);
+				while (!this.closed && this.queuedSessionFiles.size > 0) {
+					const queuedSessionFiles = Array.from(this.queuedSessionFiles);
+					this.queuedSessionFiles.clear();
+					await this.sync({
+						reason: "queued-session-files",
+						sessionFiles: queuedSessionFiles
+					});
+				}
+			} finally {
+				this.queuedSessionSync = null;
+			}
+		})();
+		return this.queuedSessionSync;
+	}
+	isReadonlyDbError(err) {
+		const readonlyPattern = /attempt to write a readonly database|database is read-only|SQLITE_READONLY/i;
+		const messages = /* @__PURE__ */ new Set();
+		const pushValue = (value) => {
+			if (typeof value !== "string") return;
+			const normalized = value.trim();
+			if (!normalized) return;
+			messages.add(normalized);
+		};
+		pushValue(err instanceof Error ? err.message : String(err));
+		if (err && typeof err === "object") {
+			const record = err;
+			pushValue(record.message);
+			pushValue(record.code);
+			pushValue(record.name);
+			if (record.cause && typeof record.cause === "object") {
+				const cause = record.cause;
+				pushValue(cause.message);
+				pushValue(cause.code);
+				pushValue(cause.name);
+			}
+		}
+		return [...messages].some((value) => readonlyPattern.test(value));
+	}
+	extractErrorReason(err) {
+		if (err instanceof Error && err.message.trim()) return err.message;
+		if (err && typeof err === "object") {
+			const record = err;
+			if (typeof record.message === "string" && record.message.trim()) return record.message;
+			if (typeof record.code === "string" && record.code.trim()) return record.code;
+		}
+		return String(err);
+	}
+	async runSyncWithReadonlyRecovery(params) {
+		try {
+			await this.runSync(params);
+			return;
+		} catch (err) {
+			if (!this.isReadonlyDbError(err) || this.closed) throw err;
+			const reason = this.extractErrorReason(err);
+			this.readonlyRecoveryAttempts += 1;
+			this.readonlyRecoveryLastError = reason;
+			log.warn(`memory sync readonly handle detected; reopening sqlite connection`, { reason });
+			try {
+				this.db.close();
+			} catch {}
+			this.db = this.openDatabase();
+			this.vectorReady = null;
+			this.vector.available = null;
+			this.vector.loadError = void 0;
+			this.ensureSchema();
+			const meta = this.readMeta();
+			this.vector.dims = meta?.vectorDims;
+			try {
+				await this.runSync(params);
+				this.readonlyRecoverySuccesses += 1;
+			} catch (retryErr) {
+				this.readonlyRecoveryFailures += 1;
+				throw retryErr;
+			}
+		}
+	}
+	async readFile(params) {
+		return await readMemoryFile({
+			workspaceDir: this.workspaceDir,
+			extraPaths: this.settings.extraPaths,
+			relPath: params.relPath,
+			from: params.from,
+			lines: params.lines
+		});
+	}
+	status() {
+		const sourceFilter = this.buildSourceFilter();
+		const files = this.db.prepare(`SELECT COUNT(*) as c FROM files WHERE 1=1${sourceFilter.sql}`).get(...sourceFilter.params);
+		const chunks = this.db.prepare(`SELECT COUNT(*) as c FROM chunks WHERE 1=1${sourceFilter.sql}`).get(...sourceFilter.params);
+		const sourceCounts = (() => {
+			const sources = Array.from(this.sources);
+			if (sources.length === 0) return [];
+			const bySource = /* @__PURE__ */ new Map();
+			for (const source of sources) bySource.set(source, {
+				files: 0,
+				chunks: 0
+			});
+			const fileRows = this.db.prepare(`SELECT source, COUNT(*) as c FROM files WHERE 1=1${sourceFilter.sql} GROUP BY source`).all(...sourceFilter.params);
+			for (const row of fileRows) {
+				const entry = bySource.get(row.source) ?? {
+					files: 0,
+					chunks: 0
+				};
+				entry.files = row.c ?? 0;
+				bySource.set(row.source, entry);
+			}
+			const chunkRows = this.db.prepare(`SELECT source, COUNT(*) as c FROM chunks WHERE 1=1${sourceFilter.sql} GROUP BY source`).all(...sourceFilter.params);
+			for (const row of chunkRows) {
+				const entry = bySource.get(row.source) ?? {
+					files: 0,
+					chunks: 0
+				};
+				entry.chunks = row.c ?? 0;
+				bySource.set(row.source, entry);
+			}
+			return sources.map((source) => Object.assign({ source }, bySource.get(source)));
+		})();
+		const searchMode = this.provider || !this.providerInitialized ? "hybrid" : "fts-only";
+		const providerInfo = this.provider ? {
+			provider: this.provider.id,
+			model: this.provider.model
+		} : this.providerInitialized ? {
+			provider: "none",
+			model: void 0
+		} : {
+			provider: this.requestedProvider,
+			model: this.settings.model || void 0
+		};
+		return {
+			backend: "builtin",
+			files: files?.c ?? 0,
+			chunks: chunks?.c ?? 0,
+			dirty: this.dirty || this.sessionsDirty,
+			workspaceDir: this.workspaceDir,
+			dbPath: this.settings.store.path,
+			provider: providerInfo.provider,
+			model: providerInfo.model,
+			requestedProvider: this.requestedProvider,
+			sources: Array.from(this.sources),
+			extraPaths: this.settings.extraPaths,
+			sourceCounts,
+			cache: this.cache.enabled ? {
+				enabled: true,
+				entries: this.db.prepare(`SELECT COUNT(*) as c FROM ${EMBEDDING_CACHE_TABLE}`).get()?.c ?? 0,
+				maxEntries: this.cache.maxEntries
+			} : {
+				enabled: false,
+				maxEntries: this.cache.maxEntries
+			},
+			fts: {
+				enabled: this.fts.enabled,
+				available: this.fts.available,
+				error: this.fts.loadError
+			},
+			fallback: this.fallbackReason ? {
+				from: this.fallbackFrom ?? "local",
+				reason: this.fallbackReason
+			} : void 0,
+			vector: {
+				enabled: this.vector.enabled,
+				available: this.vector.available ?? void 0,
+				extensionPath: this.vector.extensionPath,
+				loadError: this.vector.loadError,
+				dims: this.vector.dims
+			},
+			batch: {
+				enabled: this.batch.enabled,
+				failures: this.batchFailureCount,
+				limit: BATCH_FAILURE_LIMIT,
+				wait: this.batch.wait,
+				concurrency: this.batch.concurrency,
+				pollIntervalMs: this.batch.pollIntervalMs,
+				timeoutMs: this.batch.timeoutMs,
+				lastError: this.batchFailureLastError,
+				lastProvider: this.batchFailureLastProvider
+			},
+			custom: {
+				searchMode,
+				providerUnavailableReason: this.providerUnavailableReason,
+				readonlyRecovery: {
+					attempts: this.readonlyRecoveryAttempts,
+					successes: this.readonlyRecoverySuccesses,
+					failures: this.readonlyRecoveryFailures,
+					lastError: this.readonlyRecoveryLastError
+				}
+			}
+		};
+	}
+	async probeVectorAvailability() {
+		if (!this.vector.enabled) return false;
+		await this.ensureProviderInitialized();
+		if (!this.provider) return false;
+		return this.ensureVectorReady();
+	}
+	async probeEmbeddingAvailability() {
+		await this.ensureProviderInitialized();
+		if (!this.provider) return {
+			ok: false,
+			error: this.providerUnavailableReason ?? "No embedding provider available (FTS-only mode)"
+		};
+		try {
+			await this.embedBatchWithRetry(["ping"]);
+			return { ok: true };
+		} catch (err) {
+			return {
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		const pendingSync = this.syncing;
+		const pendingProviderInit = this.providerInitPromise;
+		if (this.watchTimer) {
+			clearTimeout(this.watchTimer);
+			this.watchTimer = null;
+		}
+		if (this.sessionWatchTimer) {
+			clearTimeout(this.sessionWatchTimer);
+			this.sessionWatchTimer = null;
+		}
+		if (this.intervalTimer) {
+			clearInterval(this.intervalTimer);
+			this.intervalTimer = null;
+		}
+		if (this.watcher) {
+			await this.watcher.close();
+			this.watcher = null;
+		}
+		if (this.sessionUnsubscribe) {
+			this.sessionUnsubscribe();
+			this.sessionUnsubscribe = null;
+		}
+		if (pendingSync) try {
+			await pendingSync;
+		} catch {}
+		if (pendingProviderInit) try {
+			await pendingProviderInit;
+		} catch {}
+		this.db.close();
+		INDEX_CACHE.delete(this.cacheKey);
+	}
+};
+//#endregion
+export { hasConfiguredMemorySecretInput as a, DEFAULT_LOCAL_MODEL as i, closeAllMemoryIndexManagers as n, collectProviderApiKeysForExecution as o, readAgentMemoryFile as r, executeWithApiKeyRotation as s, MemoryIndexManager as t };