@agentmemory/agentmemory 0.9.31 → 0.9.32

package/dist/{compression-recovery-CnhLQC6N.mjs → compression-recovery-CZh63Jmz.mjs}

@@ -1,5 +1,5 @@
 import { a as KV, l as hasCjk, n as isKeyedLockHeld, o as fingerprintId, r as withKeyedLock, s as generateId, t as afterKeyedLock, u as segmentCjk } from "./keyed-mutex-DCUh7PG-.mjs";
-import { D as logger, Q as getVectorBackfillMax, R as getAgentId, _ as safeAudit, c as memoryToObservation, d as isSearchResultLayer, f as matchesSearchLayer, h as recordAudit, l as getSearchResultLayer, lt as isVectorBackfillAllEnabled, o as buildRecallResponse, st as isGraphExtractionEnabled, tt as isAgentScopeIsolated, u as isSearchLayer } from "./secret-store-D9GwO0xp.mjs";
+import { H as getAgentId, _ as recordAudit, at as isAgentScopeIsolated, c as memoryToObservation, d as getSearchResultLayer, dt as isGraphExtractionEnabled, f as isSearchLayer, k as logger, l as observationEmbedText, m as matchesSearchLayer, nt as getVectorBackfillMax, o as buildRecallResponse, p as isSearchResultLayer, pt as isVectorBackfillAllEnabled, y as safeAudit } from "./secret-store-iYXRcrO8.mjs";
 import { i as isManagedImagePath } from "./image-store-BsN4vyjr.mjs";
 import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, utimesSync, writeFileSync, writeSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -128,7 +128,29 @@ function resolveDataDir(options = {}) {
 }
 //#endregion
 //#region src/functions/privacy.ts
-const PRIVATE_TAG_RE = /<private>[\s\S]*?<\/private>/gi;
+const PRIVATE_TAG_TOKEN_RE = /<private(?=\s|>)[^>]*>|<\/private\s*>/gi;
+function redactPrivateBlocks(input) {
+	const tokens = new RegExp(PRIVATE_TAG_TOKEN_RE.source, PRIVATE_TAG_TOKEN_RE.flags);
+	let out = "";
+	let cursor = 0;
+	let depth = 0;
+	for (let match = tokens.exec(input); match; match = tokens.exec(input)) {
+		const closing = match[0].startsWith("</");
+		if (depth === 0) {
+			if (closing) continue;
+			out += input.slice(cursor, match.index);
+			depth = 1;
+		} else if (closing) {
+			depth -= 1;
+			if (depth === 0) {
+				out += "[REDACTED]";
+				cursor = match.index + match[0].length;
+			}
+		} else depth += 1;
+	}
+	if (depth > 0) return `${out}[REDACTED]`;
+	return out + input.slice(cursor);
+}
 const SECRET_PATTERN_SOURCES = [
 	/(?:api[_-]?key|secret|token|password|credential|auth)[\s]*[=:]\s*["']?[A-Za-z0-9_\-/.+]{20,}["']?/gi,
 	/Bearer\s+[A-Za-z0-9._\-+/=]{20,}/gi,
@@ -148,7 +170,7 @@ const SECRET_PATTERN_SOURCES = [
 const PRIVATE_KEY_BLOCK_RE = /-----BEGIN [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY(?: BLOCK)?-----|$)/g;
 const URL_CREDENTIALS_RE = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/?#@:"'<>]*:[^\s/?#@"'<>]+@/gi;
 function stripPrivateData(input) {
-	let result = input.replace(PRIVATE_TAG_RE, "[REDACTED]");
+	let result = redactPrivateBlocks(input);
 	result = result.replace(new RegExp(PRIVATE_KEY_BLOCK_RE.source, PRIVATE_KEY_BLOCK_RE.flags), "[REDACTED_SECRET]");
 	result = result.replace(new RegExp(URL_CREDENTIALS_RE.source, URL_CREDENTIALS_RE.flags), "$1[REDACTED_SECRET]@");
 	for (const source of SECRET_PATTERN_SOURCES) {
@@ -2686,7 +2708,7 @@ const FUNCTION_FIXES = {
 	"mem::compress": "Compression calls your LLM provider. Check the provider key and model, or set AGENTMEMORY_AUTO_COMPRESS=false to use zero-LLM compression.",
 	"mem::graph-extract": "Graph extraction calls your LLM provider. Check the provider key and model, or set GRAPH_EXTRACTION_ENABLED=false."
 };
-const LLM_KEY_FIX = "Add one LLM provider key (for example ANTHROPIC_API_KEY or OPENAI_API_KEY) to ~/.agentmemory/.env and restart.";
+const LLM_KEY_FIX = "Set AGENTMEMORY_LLM_PROVIDER and that provider's key (for example AGENTMEMORY_LLM_PROVIDER=anthropic and ANTHROPIC_API_KEY) in ~/.agentmemory/.env and restart.";
 const OFF_WITHOUT_LLM = [
 	"session summaries",
 	"consolidation into semantic facts and procedures",
@@ -2795,8 +2817,17 @@ function evaluateStatus(input) {
 		level: "info",
 		code: "no-llm-provider",
 		message: "No LLM provider is configured, so summaries, consolidation and graph extraction stay off. Search still works.",
-		fix: LLM_KEY_FIX
+		fix: input.providerHint || "Set AGENTMEMORY_LLM_PROVIDER and that provider's key (for example AGENTMEMORY_LLM_PROVIDER=anthropic and ANTHROPIC_API_KEY) in ~/.agentmemory/.env and restart."
 	});
+	if (input.embeddingHint) {
+		const keyMissing = input.embeddingHint.startsWith("EMBEDDING_PROVIDER=");
+		problems.push({
+			level: "info",
+			code: keyMissing ? "embedding-provider-key-missing" : "embedding-provider-not-chosen",
+			message: keyMissing ? "EMBEDDING_PROVIDER names a cloud provider whose key is missing, so search is keyword and graph only." : "A cloud embedding key is present, but no embedding provider is chosen, so search is keyword and graph only.",
+			fix: input.embeddingHint
+		});
+	}
 	const noLlm = input.provider === "noop";
 	const functions = markLlmFunctions(input.functionMetrics, input.provider).map((m) => ({
 		...m,
@@ -2977,7 +3008,9 @@ function evaluateStatus(input) {
 		provider: {
 			llm: input.provider,
 			route: input.provider === "noop" ? null : input.llmRoute ?? null,
+			hint: input.providerHint ?? null,
 			embeddings: input.embeddingProvider,
+			embeddingHint: input.embeddingHint ?? null,
 			circuitBreaker: input.circuitBreaker,
 			offWithoutLlm: noLlm ? OFF_WITHOUT_LLM : []
 		},
@@ -3302,7 +3335,7 @@ Rules:
 - Be concise but preserve ALL technically relevant details
 - File paths must be exact
 - Importance: 1-3 for routine reads, 4-6 for edits/commands, 7-9 for architectural decisions, 10 for breaking changes
-- Concepts should be reusable search terms (e.g., "React hooks", "SQL migration", "auth middleware")
+- Concepts should be reusable search terms (e.g., "React hooks", "SQL migration", "auth middleware"); keep them in the user's language: when the source content is not English, include at least one concept in that original language, and when the observation mixes languages include both the original-language and English terms so search works in either
 - Strip any secrets, tokens, or credentials from the output`;
 function buildCompressionPrompt(observation) {
 	const parts = [`Timestamp: ${observation.timestamp}`, `Hook: ${observation.hookType}`];
@@ -3684,6 +3717,9 @@ function getSynonyms(stemmedTerm) {
 }
 //#endregion
 //#region src/state/search-index.ts
+const USER_PROMPT_TERM_CAP = 2e3;
+const ASSISTANT_RESPONSE_TERM_CAP = 1e3;
+const TOOL_OUTPUT_TERM_CAP = 1e3;
 var SearchIndex = class SearchIndex {
 	entries = /* @__PURE__ */ new Map();
 	invertedIndex = /* @__PURE__ */ new Map();
@@ -3942,6 +3978,9 @@ var SearchIndex = class SearchIndex {
 			...obs.files,
 			obs.type
 		];
+		if (obs.source?.userPrompt) parts.push(obs.source.userPrompt.slice(0, USER_PROMPT_TERM_CAP));
+		if (obs.source?.assistantResponse) parts.push(obs.source.assistantResponse.slice(0, ASSISTANT_RESPONSE_TERM_CAP));
+		if (obs.source?.toolName === "conversation" && typeof obs.source.toolOutput === "string") parts.push(obs.source.toolOutput.slice(0, TOOL_OUTPUT_TERM_CAP));
 		return this.tokenize(parts.join(" ").toLowerCase());
 	}
 	tokenize(text) {
@@ -4449,7 +4488,11 @@ async function indexRecords(observations, memories) {
 				id: memory.id,
 				revision,
 				sessionId: memory.sessionIds?.[0] ?? "memory",
-				text: memory.title + " " + memory.content,
+				text: observationEmbedText({
+					title: memory.title,
+					narrative: memory.content,
+					concepts: memory.concepts
+				}),
 				context: {
 					kind: "memory",
 					logId: memory.id
@@ -4463,7 +4506,7 @@ async function indexRecords(observations, memories) {
 				id: obs.id,
 				revision,
 				sessionId: obs.sessionId,
-				text: obs.title + " " + obs.narrative,
+				text: observationEmbedText(obs),
 				context: {
 					kind: "observation",
 					logId: obs.id
@@ -4496,21 +4539,36 @@ async function findUnindexedObservations(kv) {
 		missing
 	};
 }
-const SESSIONS_LIST_RETRY_ATTEMPTS = 3;
-const SESSIONS_LIST_RETRY_BASE_MS = 250;
+const LIST_RETRY_ATTEMPTS = 8;
+const LIST_RETRY_BASE_MS = 2500;
+const LIST_RETRY_BUDGET_MS = 7e4;
 function delay(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function listSessionsWithRetry(kv) {
+function isStateNotReadyError(err) {
+	const code = err?.code;
+	if (code === "function_not_found" || code === "invocation_timeout" || code === "timeout" || code === "ECONNRESET" || code === "ECONNREFUSED" || code === "EPIPE") return true;
+	const message = err instanceof Error ? err.message : String(err);
+	return /function_not_found|Function state::\w+ not found|timed out|timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE|socket hang up|connection (?:closed|reset)/i.test(message);
+}
+async function listWithRetry(kv, scope, label, deadline) {
 	let lastErr;
-	for (let attempt = 0; attempt < SESSIONS_LIST_RETRY_ATTEMPTS; attempt++) try {
-		return await kv.list(KV.sessions);
-	} catch (err) {
-		lastErr = err;
-		if (attempt < SESSIONS_LIST_RETRY_ATTEMPTS - 1) await delay(SESSIONS_LIST_RETRY_BASE_MS * (attempt + 1));
+	let attempts = 0;
+	while (attempts < LIST_RETRY_ATTEMPTS) {
+		attempts++;
+		try {
+			return await kv.list(scope);
+		} catch (err) {
+			lastErr = err;
+			if (!isStateNotReadyError(err)) break;
+			const remaining = deadline - performance.now();
+			const wait = LIST_RETRY_BASE_MS * attempts;
+			if (attempts >= LIST_RETRY_ATTEMPTS || wait >= remaining) break;
+			await delay(wait);
+		}
 	}
-	logger.warn("rebuildKeywordIndex: failed to load sessions after retries", {
-		attempts: SESSIONS_LIST_RETRY_ATTEMPTS,
+	logger.warn(`${label}: failed to load`, {
+		attempts,
 		error: lastErr instanceof Error ? lastErr.message : String(lastErr)
 	});
 	return null;
@@ -4560,20 +4618,24 @@ async function runKeywordRebuild(kv, vectorBackfillSince) {
 	};
 	let documents = 0;
 	let memoriesLoaded = false;
-	try {
-		const memories = await kv.list(KV.memories);
+	const listDeadline = performance.now() + LIST_RETRY_BUDGET_MS;
+	const memories = await listWithRetry(kv, KV.memories, "rebuildKeywordIndex: memories", listDeadline);
+	const sessions = await listWithRetry(kv, KV.sessions, "rebuildKeywordIndex: sessions", listDeadline);
+	if (memories === null) bm25RebuildIncomplete = true;
+	else {
 		memoriesLoaded = true;
 		for (const memory of memories) {
 			if (memory.isLatest === false) continue;
 			if (!memory.title || !memory.content) continue;
 			idx.add(memoryToObservation(memory), "memory");
-			consider(memory.id, memory.sessionIds?.[0] ?? "memory", memory.title + " " + memory.content, memory.createdAt, "memory");
+			consider(memory.id, memory.sessionIds?.[0] ?? "memory", observationEmbedText({
+				title: memory.title,
+				narrative: memory.content,
+				concepts: memory.concepts
+			}), memory.createdAt, "memory");
 			documents++;
 		}
-	} catch (err) {
-		logger.warn("rebuildKeywordIndex: failed to load memories", { error: err instanceof Error ? err.message : String(err) });
 	}
-	const sessions = await listSessionsWithRetry(kv);
 	if (sessions === null) {
 		bm25RebuildIncomplete = true;
 		if (memoriesLoaded) memoryIndexReady = true;
@@ -4597,7 +4659,7 @@ async function runKeywordRebuild(kv, vectorBackfillSince) {
 		for (const obs of results.flat()) {
 			if (!obs.title || !obs.narrative) continue;
 			idx.add(obs);
-			consider(obs.id, obs.sessionId, obs.title + " " + obs.narrative, obs.timestamp, "observation");
+			consider(obs.id, obs.sessionId, observationEmbedText(obs), obs.timestamp, "observation");
 			documents++;
 		}
 	}
@@ -4704,6 +4766,7 @@ function registerSearchFunction(sdk, kv) {
 		if (data.targetLayer !== void 0 && !isSearchLayer(data.targetLayer)) throw new Error("mem::search: targetLayer must be one of 'all', 'memory', or 'observation'");
 		const targetLayer = data.targetLayer ?? "all";
 		const MAX_LIMIT = 100;
+		const MAX_CANDIDATES = 1e3;
 		let effectiveLimit = 20;
 		if (data.limit !== void 0) {
 			if (!Number.isInteger(data.limit) || data.limit < 1) throw new Error("mem::search: limit must be a positive integer");
@@ -4741,7 +4804,7 @@ function registerSearchFunction(sdk, kv) {
 			await rebuildPromise;
 		}
 		const filtering = !!(projectFilter || cwdFilter || filterAgentId);
-		const fetchLimit = filtering ? Math.max(effectiveLimit * 10, 100) : effectiveLimit;
+		let fetchLimit = filtering ? Math.max(effectiveLimit * 10, 100) : effectiveLimit;
 		let results;
 		const authorizeGraph = async (record, sessionId, read) => {
 			if (filterAgentId !== void 0 && record.agentId !== filterAgentId) return false;
@@ -4755,25 +4818,12 @@ function registerSearchFunction(sdk, kv) {
 			}
 			return true;
 		};
-		if (hybridRanker) try {
-			results = (await hybridRanker(query, fetchLimit, targetLayer, authorizeGraph)).map((r) => ({
-				obsId: r.observation.id,
-				sessionId: r.sessionId,
-				score: r.combinedScore,
-				observation: r.observation,
-				layer: r.layer
-			}));
-		} catch (err) {
-			logger.warn("hybrid ranking failed, falling back to keyword search", { error: err instanceof Error ? err.message : String(err) });
-			results = idx.search(query, fetchLimit, targetLayer);
-		}
-		else results = idx.search(query, fetchLimit, targetLayer);
 		const sessionCache = /* @__PURE__ */ new Map();
 		const loadSession = async (sessionId) => {
 			if (sessionCache.has(sessionId)) return sessionCache.get(sessionId);
-			const s = await kv.get(KV.sessions, sessionId);
-			sessionCache.set(sessionId, s ?? null);
-			return s ?? null;
+			const pending = kv.get(KV.sessions, sessionId).then((session) => session ?? null);
+			sessionCache.set(sessionId, pending);
+			return pending;
 		};
 		const memoryProjectCache = /* @__PURE__ */ new Map();
 		const loadMemoryProject = async (obsId) => {
@@ -4782,53 +4832,88 @@ function registerSearchFunction(sdk, kv) {
 			memoryProjectCache.set(obsId, proj);
 			return proj;
 		};
-		const earlyCap = filterAgentId ? fetchLimit : effectiveLimit;
-		const candidates = [];
-		for (const r of results) {
-			if (candidates.length >= earlyCap) break;
-			const layer = r.layer ?? idx.layerOf(r.obsId) ?? getSearchResultLayer(r.obsId, r.sessionId);
-			if (!matchesSearchLayer(r.obsId, r.sessionId, targetLayer, layer)) continue;
-			if (filtering) {
-				const memoryProject = projectFilter && layer === "memory" ? await loadMemoryProject(r.obsId) : null;
-				if (projectFilter && memoryProject !== null && memoryProject !== projectFilter) continue;
-				const session = await loadSession(r.sessionId);
-				if (session) {
-					if (projectFilter && memoryProject === null && session.project !== projectFilter) continue;
-					if (cwdFilter && session.cwd !== cwdFilter) continue;
+		const observationCache = /* @__PURE__ */ new Map();
+		const hybridRequest = {};
+		let enriched = [];
+		let useHybridRanker = hybridRanker !== null;
+		while (true) {
+			hybridRequest.candidateCount = void 0;
+			if (useHybridRanker && hybridRanker) try {
+				results = (await hybridRanker(query, fetchLimit, targetLayer, authorizeGraph, hybridRequest)).map((r) => ({
+					obsId: r.observation.id,
+					sessionId: r.sessionId,
+					score: r.combinedScore,
+					observation: r.observation,
+					layer: r.layer
+				}));
+			} catch (err) {
+				hybridRequest.candidateCount = void 0;
+				logger.warn("hybrid ranking failed", { error: err instanceof Error ? err.message : String(err) });
+				if (enriched.length > 0) break;
+				useHybridRanker = false;
+				results = idx.search(query, fetchLimit, targetLayer);
+			}
+			else results = idx.search(query, fetchLimit, targetLayer);
+			enriched = [];
+			let batchSize = Math.min(10, effectiveLimit);
+			for (let offset = 0; offset < Math.min(results.length, fetchLimit) && enriched.length < effectiveLimit;) {
+				const batch = results.slice(offset, Math.min(offset + batchSize, fetchLimit));
+				offset += batch.length;
+				const obsResults = await Promise.all(batch.map(async (r) => {
+					const layer = r.layer ?? idx.layerOf(r.obsId) ?? getSearchResultLayer(r.obsId, r.sessionId);
+					if (!matchesSearchLayer(r.obsId, r.sessionId, targetLayer, layer)) return null;
+					if (filtering) {
+						const memoryProject = projectFilter && layer === "memory" ? await loadMemoryProject(r.obsId) : null;
+						if (projectFilter && memoryProject !== null && memoryProject !== projectFilter) return null;
+						const session = projectFilter || cwdFilter ? await loadSession(r.sessionId) : null;
+						if (projectFilter && memoryProject === null && !session) return null;
+						if (cwdFilter && layer === "observation" && !session) return null;
+						if (session) {
+							if (projectFilter && memoryProject === null && session.project !== projectFilter) return null;
+							if (cwdFilter && session.cwd !== cwdFilter) return null;
+						}
+					}
+					const key = JSON.stringify([r.obsId, r.sessionId]);
+					let pending = observationCache.get(key);
+					if (!pending) {
+						pending = (async () => {
+							if (r.observation) return {
+								observation: r.observation,
+								layer: r.layer ?? idx.layerOf(r.obsId) ?? getSearchResultLayer(r.obsId, r.sessionId)
+							};
+							const obs = await kv.get(KV.observations(r.sessionId), r.obsId).catch(() => null);
+							if (obs) return {
+								observation: obs,
+								layer: "observation"
+							};
+							const mem = await kv.get(KV.memories, r.obsId).catch(() => null);
+							return mem ? {
+								observation: memoryToObservation(mem),
+								layer: "memory"
+							} : null;
+						})();
+						observationCache.set(key, pending);
+					}
+					return pending;
+				}));
+				for (let i = 0; i < batch.length; i++) {
+					const resolved = obsResults[i];
+					if (!resolved) continue;
+					const obs = resolved.observation;
+					if (!matchesSearchLayer(obs.id, obs.sessionId, targetLayer, resolved.layer)) continue;
+					if (filterAgentId !== void 0 && obs.agentId !== filterAgentId) continue;
+					if (enriched.length >= effectiveLimit) break;
+					enriched.push({
+						observation: withoutObservationSource(obs),
+						layer: resolved.layer,
+						score: batch[i].score,
+						sessionId: batch[i].sessionId
+					});
 				}
+				batchSize = Math.min(10, Math.max(effectiveLimit - enriched.length, batchSize * 2));
 			}
-			candidates.push(r);
-		}
-		const obsResults = await Promise.all(candidates.map(async (r) => {
-			if (r.observation) return {
-				observation: r.observation,
-				layer: r.layer ?? idx.layerOf(r.obsId) ?? getSearchResultLayer(r.obsId, r.sessionId)
-			};
-			const obs = await kv.get(KV.observations(r.sessionId), r.obsId).catch(() => null);
-			if (obs) return {
-				observation: obs,
-				layer: "observation"
-			};
-			const mem = await kv.get(KV.memories, r.obsId).catch(() => null);
-			return mem ? {
-				observation: memoryToObservation(mem),
-				layer: "memory"
-			} : null;
-		}));
-		const enriched = [];
-		for (let i = 0; i < candidates.length; i++) {
-			const resolved = obsResults[i];
-			if (!resolved) continue;
-			const obs = resolved.observation;
-			if (!matchesSearchLayer(obs.id, obs.sessionId, targetLayer, resolved.layer)) continue;
-			if (filterAgentId !== void 0 && obs.agentId !== filterAgentId) continue;
-			if (enriched.length >= effectiveLimit) break;
-			enriched.push({
-				observation: withoutObservationSource(obs),
-				layer: resolved.layer,
-				score: candidates[i].score,
-				sessionId: candidates[i].sessionId
-			});
+			if (!filtering || enriched.length >= effectiveLimit || (hybridRequest.candidateCount ?? results.length) < fetchLimit || fetchLimit >= MAX_CANDIDATES) break;
+			fetchLimit = Math.min(fetchLimit * 2, MAX_CANDIDATES);
 		}
 		const response = buildRecallResponse(enriched, format, tokenBudget);
 		recordAccessBatch(kv, enriched.slice(0, response.results.length).map((result) => result.observation.id));
@@ -5579,7 +5664,7 @@ function registerCompressFunction(sdk, kv, provider, metricsStore) {
 				retryable: false
 			};
 			const committedRevision = observationRevision(compressed);
-			await bounded(() => vectorIndexAddGuarded(observationId, sessionId, compressed.title + " " + compressed.narrative, {
+			await bounded(() => vectorIndexAddGuarded(observationId, sessionId, observationEmbedText(compressed), {
 				kind: "observation",
 				logId: observationId
 			}, (embedding, isCurrent) => withKeyedLock(`obs:${sessionId}`, async () => {
@@ -5909,4 +5994,4 @@ function registerCompressionRecovery(sdk, kv) {
 //#endregion
 export { normalizeAccessLog as $, resolveDataDir as $t, getVectorBackfillState as A, withGraphSnapshotUnknownMutation as At, scheduleIndexSave as B, resolveGraphScope as Bt, findUnindexedObservations as C, initializeGraphIndex as Ct, getKeywordRebuildEpoch as D, recoverGraphIndex as Dt, getIndexPersistenceStatus as E, reconcileGraphIndexRecord as Et, isMemoryIndexReady as F, isLegacyGraphState as Ft, setVectorBackfillState as G, retainSent as Gt, setHybridRanker as H, drainSpool as Ht, markKeywordRebuildPending as I, notifyGraphGenerationChange as It, vectorIndexRemove as J, spoolSummary as Jt, setVectorIndex as K, spoolDir as Kt, rankMemoryIds as L, pinGraphState as Lt, indexRecords as M, noteGraphSnapshotWrite as Mt, isBm25RebuildIncomplete as N, withoutGraphRecovery as Nt, getPendingVectorBackfillCount as O, withGraphIndexMutation as Ot, isKeywordRebuildInProgress as P, getGraphGeneration as Pt, emptyAccessLog as Q, withWriteScrubbing as Qt, rebuildKeywordIndex as R, pinGraphStateGeneration as Rt, backfillVectorBacklog as S, graphEdgeLookupKey as St, getEmbeddingProvider as T, normalizeGraphIndexText as Tt, setIndexPersistence as U, parseSentMark as Ut, setEmbeddingProvider as V, setGraphGenerationListener as Vt, setPendingVectorBackfillCount as W, reconcileSent as Wt, withoutObservationSource as X, scrubRecord as Xt, rawFromObservationSource as Y, registerPrivacyFunction as Yt, deleteAccessLog as Z, stripPrivateData as Zt, getLiveEventsStats as _, GRAPH_INDEX_MAX_ID_BYTES as _t, markCompressionDispatchFailed as a, runtimeMetadataPath as an, markLlmFunctions as at, validateOutput as b, finishGraphIndexBuild as bt, isValidEventId as c, singleFlight as ct, budgetLiveObservationSource as d, runGraphCompactOnBoot as dt, SHUTDOWN_FLUSH_TIMEOUT_MS as en, recordAccessBatch as et, SAFE_PAYLOAD_BYTES as f, setGraphCompactBootDisabled as ft, emitLiveEvent as g, registerGraphFunction as gt, payloadByteLength as h, persistGraphDelta as ht, compressionRaw as i, settleWithin as in, evaluateStatus as it, getVectorIndex as j, ensureGraphConsistency as jt, getSearchIndex as k, withGraphSnapshotIndexBarrier as kt, buildSyntheticCompression as l, GRAPH_COMPACT_BOOT_DELAY_MS as lt, oversizedPayloadError as m, boundSources as mt, compressionInFlight as n, registerStartupCleanup as nn, CURL_AUTH_HEADER as nt, needsCompression as o, prefersHtml as ot, checkPayloadFrameSize as p, COMPACT_SCOPES as pt, vectorIndexAddGuarded as q, spoolPolicy as qt, registerCompressFunction as r, runStartupCleanup as rn, UNINDEXED_SCAN_REUSE_MS as rt, pendingCompression as s, renderStatusHtml as st, parseCompressionScope as t, SHUTDOWN_HARD_EXIT_MS as tn, SearchIndex as tt, budgetImportedObservationSources as u, getGraphCompactBootStatus as ut, liveEvents as v, GraphIndexError as vt, flushIndexSave as w, mutateIndexedGraphRecord as wt, SummaryOutputSchema as x, getGraphIndexStatus as xt, scoreSummary as y, createGraphIndexReader as yt, registerSearchFunction as z, replaceGraphGeneration as zt };
 
-//# sourceMappingURL=compression-recovery-CnhLQC6N.mjs.map
+//# sourceMappingURL=compression-recovery-CZh63Jmz.mjs.map