@romiluz/clawmongo 2026.3.26 → 2026.3.28

package/dist/{mongodb-manager-BJ0PAYF_.js → mongodb-manager-NkerSpvH.js}

@@ -1,22 +1,42 @@
 import { n as redactSensitiveText } from "./redact-BDinS1q9.js";
 import { t as createSubsystemLogger } from "./subsystem-VzQeL-96.js";
-import { p as resolveAgentWorkspaceDir } from "./agent-scope-BROpmzKv.js";
+import { p as resolveAgentWorkspaceDir } from "./agent-scope-DXZH506l.js";
 import { c as resolveSessionTranscriptsDirForAgent } from "./paths-CGTGVWe2.js";
-import { a as listMemoryFiles, n as chunkMarkdown, o as normalizeExtraMemoryPaths, r as hashText, t as buildFileEntry } from "./internal-Bg_k56Pk.js";
-import { T as structuredMemCollection, _ as metaCollection, a as ensureCollections, b as projectionRunsCollection, c as ensureStandardIndexes, d as episodesCollection, f as eventsCollection, g as kbCollection, h as kbChunksCollection, l as entitiesCollection, m as ingestRunsCollection, n as chunksCollection, p as filesCollection, r as detectCapabilities, s as ensureSearchIndexes, u as entityLinksCollection, w as relevanceRunsCollection, x as relationsCollection, y as proceduresCollection } from "./mongodb-schema-BI4Ze_ZV.js";
+import { a as listMemoryFiles, n as chunkMarkdown, o as normalizeExtraMemoryPaths, r as hashText, t as buildFileEntry } from "./internal-DLE9baj7.js";
+import { C as relationsCollection, D as structuredMemCollection, E as relevanceRunsCollection, S as queryCacheCollection, _ as metaCollection, a as ensureCollections, b as proceduresCollection, c as ensureStandardIndexes, d as episodesCollection, f as eventsCollection, g as kbCollection, h as kbChunksCollection, k as telemetryCollection, l as entitiesCollection, m as ingestRunsCollection, n as chunksCollection, p as filesCollection, r as detectCapabilities, s as ensureSearchIndexes, u as entityLinksCollection, x as projectionRunsCollection } from "./mongodb-schema-Dt6jxcPL.js";
 import { t as resolveScopeRef } from "./mongodb-scope-0bwP6Q3D.js";
-import { a as normalizeSearchResults, o as MongoDBRelevanceRuntime, r as mongoSearch } from "./mongodb-search-VFKd72IZ.js";
-import { n as writeProcedure, t as searchProcedures } from "./mongodb-procedures-DNPmmW5r.js";
-import { t as getMemoryStats } from "./mongodb-analytics-CcSYo_ae.js";
-import { n as writeStructuredMemory, t as searchStructuredMemory } from "./mongodb-structured-memory-DnwUJ6SA.js";
-import { t as searchKB } from "./mongodb-kb-search-CoIAFX8n.js";
+import { n as writeStructuredMemory, t as searchStructuredMemory } from "./mongodb-structured-memory-D-3SEfTu.js";
+import { a as normalizeSearchResults, n as buildVectorSearchStage, o as rrfScore, r as mongoSearch, s as MongoDBRelevanceRuntime } from "./mongodb-search-DMsUyfpa.js";
+import { n as writeProcedure, t as searchProcedures } from "./mongodb-procedures-DI-_Dakz.js";
+import { t as getMemoryStats } from "./mongodb-analytics-mnKJih5x.js";
+import { t as searchKB } from "./mongodb-kb-search-Dq6E746K.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
 import chokidar from "chokidar";
 import { MongoClient } from "mongodb";
+//#region src/memory/mongodb-telemetry.ts
+const log$14 = createSubsystemLogger("memory:mongodb:telemetry");
+/**
+* Emit a telemetry document to the memory_telemetry time series collection.
+* Fire-and-forget: never blocks the caller, never throws.
+* Uses insertOne with .catch() for error-swallowing.
+*/
+function emitTelemetry(db, prefix, doc) {
+	const entry = {
+		...doc,
+		ts: /* @__PURE__ */ new Date()
+	};
+	telemetryCollection(db, prefix).insertOne(entry).catch((err) => {
+		log$14.warn("telemetry emit failed", {
+			operation: doc.meta.operation,
+			error: err
+		});
+	});
+}
+//#endregion
 //#region src/memory/mongodb-ops.ts
-const log$9 = createSubsystemLogger("memory:mongodb:ops");
+const log$13 = createSubsystemLogger("memory:mongodb:ops");
 async function recordProjectionRun(params) {
 	const { db, prefix, run } = params;
 	const runId = randomUUID();
@@ -27,9 +47,18 @@ async function recordProjectionRun(params) {
 	};
 	try {
 		await projectionRunsCollection(db, prefix).insertOne(doc);
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId: run.agentId,
+				operation: "projection-run"
+			},
+			durationMs: run.durationMs,
+			ok: run.status === "ok",
+			itemCount: run.itemsProjected
+		});
 		return runId;
 	} catch (err) {
-		log$9.error("recordProjectionRun failed", {
+		log$13.error("recordProjectionRun failed", {
 			runId,
 			error: err
 		});
@@ -41,7 +70,7 @@ async function getLatestIngestRun(params) {
 	try {
 		return await ingestRunsCollection(db, prefix).findOne({ agentId }, { sort: { ts: -1 } }) ?? null;
 	} catch (err) {
-		log$9.error("getLatestIngestRun failed", {
+		log$13.error("getLatestIngestRun failed", {
 			agentId,
 			error: err
 		});
@@ -56,7 +85,7 @@ async function getLatestProjectionRun(params) {
 			projectionType
 		}, { sort: { ts: -1 } }) ?? null;
 	} catch (err) {
-		log$9.error("getLatestProjectionRun failed", {
+		log$13.error("getLatestProjectionRun failed", {
 			agentId,
 			projectionType,
 			error: err
@@ -76,7 +105,7 @@ async function getProjectionLag(params) {
 		const ts = doc.ts;
 		return Math.floor((Date.now() - ts.getTime()) / 1e3);
 	} catch (err) {
-		log$9.error("getProjectionLag failed", {
+		log$13.error("getProjectionLag failed", {
 			agentId,
 			projectionType,
 			error: err
@@ -86,7 +115,7 @@ async function getProjectionLag(params) {
 }
 //#endregion
 //#region src/memory/mongodb-events.ts
-const log$8 = createSubsystemLogger("memory:mongodb:events");
+const log$12 = createSubsystemLogger("memory:mongodb:events");
 function renderEventChunkText(event) {
 	return `${event.role.charAt(0).toUpperCase() + event.role.slice(1)}: ${event.body}`;
 }
@@ -115,7 +144,7 @@ async function writeEvent(params) {
 		...event.metadata && { metadata: event.metadata }
 	};
 	await collection.updateOne({ eventId }, { $setOnInsert: doc }, { upsert: true });
-	log$8.info(`event written: ${eventId} role=${event.role}`);
+	log$12.info(`event written: ${eventId} role=${event.role}`);
 	return {
 		eventId,
 		timestamp,
@@ -156,7 +185,7 @@ async function markEventsConsolidated(params) {
 		consolidatedAt: /* @__PURE__ */ new Date(),
 		consolidatedIntoEpisodeId: episodeId
 	} });
-	log$8.info(`marked ${result.modifiedCount} events consolidated into episode=${episodeId}`);
+	log$12.info(`marked ${result.modifiedCount} events consolidated into episode=${episodeId}`);
 	return result.modifiedCount;
 }
 /**
@@ -212,9 +241,132 @@ async function projectEventChunk(params) {
 	}).catch(() => {});
 	return { chunkCreated: result.upsertedCount > 0 };
 }
+createSubsystemLogger("memory:mongodb:entity-extractor");
+const STOP_WORDS = new Set([
+	"the",
+	"a",
+	"an",
+	"is",
+	"are",
+	"was",
+	"were",
+	"be",
+	"been",
+	"being",
+	"have",
+	"has",
+	"had",
+	"do",
+	"does",
+	"did",
+	"will",
+	"would",
+	"could",
+	"should",
+	"may",
+	"might",
+	"can",
+	"shall",
+	"must",
+	"need",
+	"not",
+	"and",
+	"or",
+	"but",
+	"if",
+	"then",
+	"else",
+	"when",
+	"where",
+	"how",
+	"what",
+	"which",
+	"who",
+	"whom",
+	"this",
+	"that",
+	"these",
+	"those",
+	"it",
+	"its",
+	"i",
+	"me",
+	"my",
+	"we",
+	"our",
+	"you",
+	"your",
+	"he",
+	"she",
+	"him",
+	"her",
+	"they",
+	"them",
+	"their"
+]);
+const MENTION_REGEX = /@(\w{3,})/g;
+const TAG_REGEX = /#(\w{3,})/g;
+const URL_REGEX = /https?:\/\/[^\s)]+/g;
+const FILE_PATH_REGEX = /(?:^|\s)((?:[\w.-]+\/)+[\w.-]+\.\w+)/g;
+const QUOTED_NAME_REGEX = /"([^"]{3,})"/g;
+const DATE_REGEX = /\b(\d{4}-\d{2}-\d{2}|\w+ \d{1,2},? \d{4}|\d{1,2}\/\d{1,2}\/\d{4})\b/g;
+var RegexEntityExtractor = class {
+	async extract(content) {
+		const entities = [];
+		const seen = /* @__PURE__ */ new Set();
+		const addEntity = (name, type) => {
+			if (type !== "document" && STOP_WORDS.has(name.toLowerCase())) return;
+			const key = `${name.toLowerCase()}:${type}`;
+			if (!seen.has(key)) {
+				seen.add(key);
+				entities.push({
+					name,
+					type,
+					confidence: .5,
+					extractionMethod: "regex"
+				});
+			}
+		};
+		for (const match of content.matchAll(MENTION_REGEX)) addEntity(match[1], "person");
+		for (const match of content.matchAll(TAG_REGEX)) addEntity(match[1], "topic");
+		for (const match of content.matchAll(URL_REGEX)) addEntity(match[0], "document");
+		for (const match of content.matchAll(FILE_PATH_REGEX)) addEntity(match[1], "document");
+		for (const match of content.matchAll(QUOTED_NAME_REGEX)) {
+			const name = match[1];
+			if (name && name.trim().length >= 3 && !STOP_WORDS.has(name.toLowerCase().trim())) {
+				const key = `${name.trim().toLowerCase()}:person`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					entities.push({
+						name: name.trim(),
+						type: "person",
+						confidence: .5,
+						extractionMethod: "regex"
+					});
+				}
+			}
+		}
+		for (const match of content.matchAll(DATE_REGEX)) {
+			const dateName = match[1].trim();
+			if (dateName.length >= 5) {
+				const key = `${dateName.toLowerCase()}:concept`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					entities.push({
+						name: dateName,
+						type: "concept",
+						confidence: .7,
+						extractionMethod: "regex"
+					});
+				}
+			}
+		}
+		return entities;
+	}
+};
 //#endregion
 //#region src/memory/mongodb-graph.ts
-const log$7 = createSubsystemLogger("memory:mongodb:graph");
+const log$10 = createSubsystemLogger("memory:mongodb:graph");
 function relationPriority(type) {
 	switch (type) {
 		case "works_on":
@@ -263,133 +415,6 @@ function inferEntityLinkType(left, right) {
 		provenance: { heuristic: "co-mentioned" }
 	};
 }
-async function upsertEntity(params) {
-	const { db, prefix, entity } = params;
-	try {
-		const collection = entitiesCollection(db, prefix);
-		const now = /* @__PURE__ */ new Date();
-		const scopeRef = resolveScopeRef({
-			scope: entity.scope,
-			scopeRef: entity.scopeRef,
-			agentId: entity.agentId
-		});
-		const setDoc = {
-			entityId: entity.entityId,
-			name: entity.name,
-			type: entity.type,
-			agentId: entity.agentId,
-			scope: entity.scope,
-			scopeRef,
-			updatedAt: now
-		};
-		if (entity.aliases !== void 0) setDoc.aliases = entity.aliases;
-		if (entity.metadata !== void 0) setDoc.metadata = entity.metadata;
-		if (entity.sourceEventIds !== void 0) setDoc.sourceEventIds = entity.sourceEventIds;
-		const upserted = (await collection.updateOne({
-			entityId: entity.entityId,
-			agentId: entity.agentId,
-			scope: entity.scope,
-			scopeRef
-		}, {
-			$set: setDoc,
-			$setOnInsert: { createdAt: now }
-		}, { upsert: true })).upsertedCount > 0;
-		log$7.info(`entity ${upserted ? "created" : "updated"}: ${entity.entityId} name=${entity.name}`);
-		return { upserted };
-	} catch (err) {
-		log$7.error(`upsertEntity failed: ${err instanceof Error ? err.message : String(err)}`);
-		throw err;
-	}
-}
-async function upsertRelation(params) {
-	const { db, prefix, relation } = params;
-	try {
-		const collection = relationsCollection(db, prefix);
-		const now = /* @__PURE__ */ new Date();
-		const scopeRef = resolveScopeRef({
-			scope: relation.scope,
-			scopeRef: relation.scopeRef,
-			agentId: relation.agentId
-		});
-		const setDoc = {
-			fromEntityId: relation.fromEntityId,
-			toEntityId: relation.toEntityId,
-			type: relation.type,
-			agentId: relation.agentId,
-			scope: relation.scope,
-			scopeRef,
-			updatedAt: now
-		};
-		if (relation.weight !== void 0) setDoc.weight = relation.weight;
-		if (relation.sourceEventIds !== void 0) setDoc.sourceEventIds = relation.sourceEventIds;
-		const upserted = (await collection.updateOne({
-			fromEntityId: relation.fromEntityId,
-			toEntityId: relation.toEntityId,
-			type: relation.type,
-			agentId: relation.agentId,
-			scope: relation.scope,
-			scopeRef
-		}, {
-			$set: setDoc,
-			$setOnInsert: { createdAt: now }
-		}, { upsert: true })).upsertedCount > 0;
-		log$7.info(`relation ${upserted ? "created" : "updated"}: ${relation.fromEntityId} -[${relation.type}]-> ${relation.toEntityId}`);
-		return { upserted };
-	} catch (err) {
-		log$7.error(`upsertRelation failed: ${err instanceof Error ? err.message : String(err)}`);
-		throw err;
-	}
-}
-async function upsertEntityLink(params) {
-	const { db, prefix, link } = params;
-	try {
-		const collection = entityLinksCollection(db, prefix);
-		const scopeRef = resolveScopeRef({
-			scope: link.scope,
-			scopeRef: link.scopeRef,
-			agentId: link.agentId
-		});
-		const pair = canonicalizeEntityPair(link.fromEntityId, link.toEntityId);
-		const linkId = link.linkId ?? makeEntityLinkId({
-			...pair,
-			linkType: link.linkType,
-			agentId: link.agentId,
-			scope: link.scope,
-			scopeRef
-		});
-		const now = link.updatedAt ?? /* @__PURE__ */ new Date();
-		const setDoc = {
-			linkId,
-			...pair,
-			linkType: link.linkType,
-			status: link.status,
-			confidence: link.confidence,
-			agentId: link.agentId,
-			scope: link.scope,
-			scopeRef,
-			updatedAt: now
-		};
-		if (link.sourceEventIds !== void 0) setDoc.sourceEventIds = link.sourceEventIds;
-		if (link.provenance !== void 0) setDoc.provenance = link.provenance;
-		return {
-			upserted: (await collection.updateOne({
-				agentId: link.agentId,
-				scope: link.scope,
-				scopeRef,
-				fromEntityId: pair.fromEntityId,
-				toEntityId: pair.toEntityId,
-				linkType: link.linkType
-			}, {
-				$set: setDoc,
-				$setOnInsert: { createdAt: now }
-			}, { upsert: true })).upsertedCount > 0,
-			linkId
-		};
-	} catch (err) {
-		log$7.error(`upsertEntityLink failed: ${err instanceof Error ? err.message : String(err)}`);
-		throw err;
-	}
-}
 async function findEntitiesByName(params) {
 	const { db, prefix, query, agentId, scope, scopeRef, limit } = params;
 	try {
@@ -404,12 +429,13 @@ async function findEntitiesByName(params) {
 		if (scopeRef) filter.scopeRef = scopeRef;
 		return await collection.find(filter).sort({ updatedAt: -1 }).limit(limit ?? 50).toArray();
 	} catch (err) {
-		log$7.error(`findEntitiesByName failed: ${err instanceof Error ? err.message : String(err)}`);
+		log$10.error(`findEntitiesByName failed: ${err instanceof Error ? err.message : String(err)}`);
 		throw err;
 	}
 }
 async function expandGraph(params) {
 	const { db, prefix, entityId, agentId, scope, scopeRef, maxDepth, bidirectional, maxConnections } = params;
+	const graphStart = Date.now();
 	try {
 		const entCol = entitiesCollection(db, prefix);
 		const relCol = relationsCollection(db, prefix);
@@ -546,133 +572,66 @@ async function expandGraph(params) {
 		});
 		const connectionLimit = maxConnections ?? 100;
 		const limitedConnections = connections.slice(0, connectionLimit);
-		if (connections.length > connectionLimit) log$7.warn(`expandGraph: truncated ${connections.length} connections to maxConnections=${connectionLimit} for entity=${entityId}`);
+		if (connections.length > connectionLimit) log$10.warn(`expandGraph: truncated ${connections.length} connections to maxConnections=${connectionLimit} for entity=${entityId}`);
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "graph-expansion"
+			},
+			durationMs: Date.now() - graphStart,
+			ok: true,
+			resultCount: limitedConnections.length
+		});
 		return {
 			rootEntity,
 			connections: limitedConnections
 		};
 	} catch (err) {
-		log$7.error(`expandGraph failed: ${err instanceof Error ? err.message : String(err)}`);
+		log$10.error(`expandGraph failed: ${err instanceof Error ? err.message : String(err)}`);
 		throw err;
 	}
 }
-const STOP_WORDS = new Set([
-	"the",
-	"a",
-	"an",
-	"is",
-	"are",
-	"was",
-	"were",
-	"be",
-	"been",
-	"being",
-	"have",
-	"has",
-	"had",
-	"do",
-	"does",
-	"did",
-	"will",
-	"would",
-	"could",
-	"should",
-	"may",
-	"might",
-	"can",
-	"shall",
-	"must",
-	"need",
-	"not",
-	"and",
-	"or",
-	"but",
-	"if",
-	"then",
-	"else",
-	"when",
-	"where",
-	"how",
-	"what",
-	"which",
-	"who",
-	"whom",
-	"this",
-	"that",
-	"these",
-	"those",
-	"it",
-	"its",
-	"i",
-	"me",
-	"my",
-	"we",
-	"our",
-	"you",
-	"your",
-	"he",
-	"she",
-	"him",
-	"her",
-	"they",
-	"them",
-	"their"
-]);
-const MENTION_REGEX = /@(\w{3,})/g;
-const TAG_REGEX = /#(\w{3,})/g;
-const URL_REGEX = /https?:\/\/[^\s)]+/g;
-const FILE_PATH_REGEX = /(?:^|\s)((?:[\w.-]+\/)+[\w.-]+\.\w+)/g;
-const QUOTED_NAME_REGEX = /"([^"]{3,})"/g;
+const defaultExtractor = new RegexEntityExtractor();
 function makeEntityId(name, type, agentId, scope, scopeRef) {
 	return createHash("sha256").update(`${agentId}:${scope}:${scopeRef}:${name.toLowerCase()}:${type}`).digest("hex").slice(0, 16);
 }
 /**
 * Extract structural entities from event content and upsert them.
-* Regex patterns: @mentions->person, #tags->topic, URLs->document,
-* file paths->document, "quoted names"->person.
+* Uses a pluggable EntityExtractor (defaults to RegexEntityExtractor).
 *
 * Deterministic entityIds via hash of name.toLowerCase() + type.
 * Fire-and-forget: caller decides whether to await.
 * SEPARATE from writeEvent -- not called automatically.
 */
 async function extractAndUpsertEntities(params) {
-	const { db, prefix, agentId, eventContent, scope, sourceEventId } = params;
+	const { db, prefix, agentId, eventContent, scope, sourceEventId, role } = params;
 	const startMs = Date.now();
 	const scopeRef = resolveScopeRef({
 		scope,
 		scopeRef: params.scopeRef,
 		agentId
 	});
+	const extractor = params.extractor ?? defaultExtractor;
+	const extractorContext = role ? {
+		agentId,
+		scope,
+		scopeRef,
+		role
+	} : void 0;
+	const extractorResults = await extractor.extract(eventContent, extractorContext);
 	const extracted = [];
 	const seen = /* @__PURE__ */ new Set();
-	function addEntity(name, type) {
-		const entityId = makeEntityId(name, type, agentId, scope, scopeRef);
+	for (const r of extractorResults) {
+		const entityId = makeEntityId(r.name, r.type, agentId, scope, scopeRef);
 		if (!seen.has(entityId)) {
 			seen.add(entityId);
 			extracted.push({
 				entityId,
-				name,
-				type
+				name: r.name,
+				type: r.type
 			});
 		}
 	}
-	for (const match of eventContent.matchAll(MENTION_REGEX)) {
-		const name = match[1];
-		if (name && !STOP_WORDS.has(name.toLowerCase())) addEntity(name, "person");
-	}
-	for (const match of eventContent.matchAll(TAG_REGEX)) {
-		const name = match[1];
-		if (name && !STOP_WORDS.has(name.toLowerCase())) addEntity(name, "topic");
-	}
-	for (const match of eventContent.matchAll(URL_REGEX)) addEntity(match[0], "document");
-	for (const match of eventContent.matchAll(FILE_PATH_REGEX)) {
-		const filePath = match[1];
-		if (filePath) addEntity(filePath, "document");
-	}
-	for (const match of eventContent.matchAll(QUOTED_NAME_REGEX)) {
-		const name = match[1];
-		if (name && name.trim().length >= 3 && !STOP_WORDS.has(name.toLowerCase().trim())) addEntity(name.trim(), "person");
-	}
 	if (extracted.length === 0) {
 		await Promise.allSettled([recordProjectionRun({
 			db,
@@ -701,57 +660,129 @@ async function extractAndUpsertEntities(params) {
 		};
 	}
 	try {
-		for (const entity of extracted) await upsertEntity({
-			db,
-			prefix,
-			entity: {
+		const now = /* @__PURE__ */ new Date();
+		const validSourceRole = role === "user" || role === "assistant" ? role : void 0;
+		const entityOps = extracted.map((entity) => ({ updateOne: {
+			filter: {
 				entityId: entity.entityId,
-				name: entity.name,
-				type: entity.type,
 				agentId,
 				scope,
-				scopeRef,
-				updatedAt: /* @__PURE__ */ new Date(),
-				...sourceEventId && { sourceEventIds: [sourceEventId] }
-			}
-		});
-		let relationsCreated = 0;
-		if (extracted.length >= 2) for (let i = 0; i < extracted.length - 1 && i < 5; i++) for (let j = i + 1; j < extracted.length && j < 6; j++) {
-			const link = inferEntityLinkType(extracted[i], extracted[j]);
-			await upsertEntityLink({
-				db,
-				prefix,
-				link: {
-					fromEntityId: extracted[i].entityId,
-					toEntityId: extracted[j].entityId,
-					linkType: link.linkType,
-					status: "active",
-					confidence: link.confidence,
-					provenance: link.provenance,
+				scopeRef
+			},
+			update: {
+				$set: {
+					entityId: entity.entityId,
+					name: entity.name,
+					type: entity.type,
 					agentId,
 					scope,
 					scopeRef,
-					...sourceEventId ? { sourceEventIds: [sourceEventId] } : {}
+					updatedAt: now,
+					...sourceEventId ? { sourceEventIds: [sourceEventId] } : {},
+					...validSourceRole ? { sourceRole: validSourceRole } : {}
+				},
+				$setOnInsert: {
+					createdAt: now,
+					extractedAt: now
 				}
-			});
-			await upsertRelation({
-				db,
-				prefix,
-				relation: {
-					fromEntityId: extracted[i].entityId,
-					toEntityId: extracted[j].entityId,
-					type: "mentioned_with",
-					weight: .2,
+			},
+			upsert: true
+		} }));
+		if (entityOps.length > 0) try {
+			await entitiesCollection(db, prefix).bulkWrite(entityOps, { ordered: false });
+		} catch (bulkErr) {
+			log$10.warn("bulkWrite entity upserts partial failure", { error: bulkErr });
+		}
+		let relationsCreated = 0;
+		if (extracted.length >= 2) {
+			const relationOps = [];
+			const linkOps = [];
+			for (let i = 0; i < extracted.length - 1 && i < 5; i++) for (let j = i + 1; j < extracted.length && j < 6; j++) {
+				const link = inferEntityLinkType(extracted[i], extracted[j]);
+				const pair = canonicalizeEntityPair(extracted[i].entityId, extracted[j].entityId);
+				const linkId = makeEntityLinkId({
+					...pair,
+					linkType: link.linkType,
 					agentId,
 					scope,
-					scopeRef,
-					updatedAt: /* @__PURE__ */ new Date(),
-					...sourceEventId && { sourceEventIds: [sourceEventId] }
-				}
-			});
-			relationsCreated++;
+					scopeRef
+				});
+				linkOps.push({ updateOne: {
+					filter: {
+						agentId,
+						scope,
+						scopeRef,
+						fromEntityId: pair.fromEntityId,
+						toEntityId: pair.toEntityId,
+						linkType: link.linkType
+					},
+					update: {
+						$set: {
+							linkId,
+							...pair,
+							linkType: link.linkType,
+							status: "active",
+							confidence: link.confidence,
+							agentId,
+							scope,
+							scopeRef,
+							updatedAt: now,
+							...link.provenance ? { provenance: link.provenance } : {},
+							...sourceEventId ? { sourceEventIds: [sourceEventId] } : {}
+						},
+						$setOnInsert: { createdAt: now }
+					},
+					upsert: true
+				} });
+				relationOps.push({ updateOne: {
+					filter: {
+						fromEntityId: extracted[i].entityId,
+						toEntityId: extracted[j].entityId,
+						type: "mentioned_with",
+						agentId,
+						scope,
+						scopeRef
+					},
+					update: {
+						$set: {
+							fromEntityId: extracted[i].entityId,
+							toEntityId: extracted[j].entityId,
+							type: "mentioned_with",
+							weight: .2,
+							agentId,
+							scope,
+							scopeRef,
+							updatedAt: now,
+							...sourceEventId ? { sourceEventIds: [sourceEventId] } : {}
+						},
+						$setOnInsert: { createdAt: now }
+					},
+					upsert: true
+				} });
+				relationsCreated++;
+			}
+			if (relationOps.length > 0) try {
+				await relationsCollection(db, prefix).bulkWrite(relationOps, { ordered: false });
+			} catch (bulkErr) {
+				log$10.warn("bulkWrite relation upserts partial failure", { error: bulkErr });
+			}
+			if (linkOps.length > 0) try {
+				await entityLinksCollection(db, prefix).bulkWrite(linkOps, { ordered: false });
+			} catch (bulkErr) {
+				log$10.warn("bulkWrite entity-link upserts partial failure", { error: bulkErr });
+			}
 		}
-		log$7.info(`extracted ${extracted.length} entities and ${relationsCreated} relations from event content for agent=${agentId}`);
+		log$10.info(`extracted ${extracted.length} entities and ${relationsCreated} relations from event content for agent=${agentId}`);
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "entity-extraction"
+			},
+			durationMs: Date.now() - startMs,
+			ok: true,
+			extractionMethod: extractorResults[0]?.extractionMethod ?? "regex",
+			entitiesExtracted: extracted.length
+		});
 		await Promise.allSettled([recordProjectionRun({
 			db,
 			prefix,
@@ -778,6 +809,16 @@ async function extractAndUpsertEntities(params) {
 			relationsCreated
 		};
 	} catch (err) {
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "entity-extraction"
+			},
+			durationMs: Date.now() - startMs,
+			ok: false,
+			extractionMethod: extractor instanceof RegexEntityExtractor ? "regex" : "llm",
+			entitiesExtracted: 0
+		});
 		await Promise.allSettled([recordProjectionRun({
 			db,
 			prefix,
@@ -799,13 +840,13 @@ async function extractAndUpsertEntities(params) {
 				durationMs: Date.now() - startMs
 			}
 		})]);
-		log$7.error(`extractAndUpsertEntities failed: ${err instanceof Error ? err.message : String(err)}`);
+		log$10.error(`extractAndUpsertEntities failed: ${err instanceof Error ? err.message : String(err)}`);
 		throw err;
 	}
 }
 //#endregion
 //#region src/memory/mongodb-episodes.ts
-const log$6 = createSubsystemLogger("memory:mongodb:episodes");
+const log$9 = createSubsystemLogger("memory:mongodb:episodes");
 function buildEpisodeSummarizerInput(events) {
 	const conversational = events.filter((event) => {
 		return event.body.trim().length > 0 && (event.role === "user" || event.role === "assistant");
@@ -846,7 +887,7 @@ async function materializeEpisode(params) {
 			scopeRef
 		});
 		if (events.length < 2) {
-			log$6.info(`skipping episode materialization: only ${events.length} events in range for agent=${agentId}`);
+			log$9.info(`skipping episode materialization: only ${events.length} events in range for agent=${agentId}`);
 			await recordProjectionRun({
 				db,
 				prefix,
@@ -866,7 +907,7 @@ async function materializeEpisode(params) {
 			timestamp: e.timestamp
 		})));
 		if (summarizerInput.length < 2) {
-			log$6.info(`skipping episode materialization: only ${summarizerInput.length} conversational events in range for agent=${agentId}`);
+			log$9.info(`skipping episode materialization: only ${summarizerInput.length} conversational events in range for agent=${agentId}`);
 			await recordProjectionRun({
 				db,
 				prefix,
@@ -915,7 +956,8 @@ async function materializeEpisode(params) {
 			$set: setDoc,
 			$setOnInsert: {
 				episodeId,
-				createdAt: now
+				createdAt: now,
+				status: "active"
 			}
 		}, { upsert: true });
 		let persistedEpisodeId = episodeId;
@@ -940,7 +982,7 @@ async function materializeEpisode(params) {
 			updatedAt: now,
 			...tags !== void 0 && { tags }
 		};
-		log$6.info(`episode materialized: ${episodeId} type=${type} events=${events.length} agent=${agentId}`);
+		log$9.info(`episode materialized: ${episodeId} type=${type} events=${events.length} agent=${agentId}`);
 		await recordProjectionRun({
 			db,
 			prefix,
@@ -965,7 +1007,7 @@ async function materializeEpisode(params) {
 				durationMs: Date.now() - startMs
 			}
 		}).catch(() => {});
-		log$6.error(`materializeEpisode failed: ${err instanceof Error ? err.message : String(err)}`);
+		log$9.error(`materializeEpisode failed: ${err instanceof Error ? err.message : String(err)}`);
 		throw err;
 	}
 }
@@ -976,14 +1018,15 @@ async function getEpisodesByTimeRange(params) {
 		const filter = {
 			agentId,
 			"timeRange.start": { $lte: end },
-			"timeRange.end": { $gte: start }
+			"timeRange.end": { $gte: start },
+			status: { $ne: "deleted" }
 		};
 		if (type) filter.type = type;
 		if (scope) filter.scope = scope;
 		if (scopeRef) filter.scopeRef = scopeRef;
 		return await col.find(filter).sort({ "timeRange.start": -1 }).limit(100).toArray();
 	} catch (err) {
-		log$6.error(`getEpisodesByTimeRange failed: ${err instanceof Error ? err.message : String(err)}`);
+		log$9.error(`getEpisodesByTimeRange failed: ${err instanceof Error ? err.message : String(err)}`);
 		throw err;
 	}
 }
@@ -996,6 +1039,7 @@ async function searchEpisodes(params) {
 		const regex = new RegExp(escapedQuery, "i");
 		const filter = {
 			agentId,
+			status: { $ne: "deleted" },
 			$or: [{ title: { $regex: regex } }, { summary: { $regex: regex } }]
 		};
 		if (scope) filter.scope = scope;
@@ -1006,7 +1050,7 @@ async function searchEpisodes(params) {
 		}
 		return await col.find(filter).sort({ updatedAt: -1 }).limit(limit ?? 50).toArray();
 	} catch (err) {
-		log$6.error(`searchEpisodes failed: ${err instanceof Error ? err.message : String(err)}`);
+		log$9.error(`searchEpisodes failed: ${err instanceof Error ? err.message : String(err)}`);
 		throw err;
 	}
 }
@@ -1095,20 +1139,20 @@ async function checkAutoEpisodeTriggers(params) {
 			eventIds,
 			episodeId: episode.episodeId
 		});
-		log$6.info(`auto episode triggered: reason=${triggerReason} episode=${episode.episodeId} events=${eventIds.length} agent=${agentId}`);
+		log$9.info(`auto episode triggered: reason=${triggerReason} episode=${episode.episodeId} events=${eventIds.length} agent=${agentId}`);
 		return {
 			triggered: true,
 			reason: triggerReason,
 			episode
 		};
 	} catch (err) {
-		log$6.error(`checkAutoEpisodeTriggers failed: ${err instanceof Error ? err.message : String(err)}`);
+		log$9.error(`checkAutoEpisodeTriggers failed: ${err instanceof Error ? err.message : String(err)}`);
 		throw err;
 	}
 }
 //#endregion
 //#region src/memory/mongodb-retrieval-planner.ts
-const log$5 = createSubsystemLogger("memory:mongodb:planner");
+const log$8 = createSubsystemLogger("memory:mongodb:planner");
 function buildKeywordRegexes(keywords) {
 	return keywords.map((kw) => new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i"));
 }
@@ -1498,7 +1542,7 @@ function planRetrieval(query, context) {
 			...Object.keys(constraints).length > 0 ? { constraints } : {}
 		};
 	} catch (err) {
-		log$5.error("planRetrieval failed", {
+		log$8.error("planRetrieval failed", {
 			query,
 			error: err
 		});
@@ -1507,7 +1551,7 @@ function planRetrieval(query, context) {
 }
 //#endregion
 //#region src/memory/mongodb-change-stream.ts
-const log$4 = createSubsystemLogger("memory:mongodb:changestream");
+const log$7 = createSubsystemLogger("memory:mongodb:changestream");
 /**
 * MongoDBChangeStreamWatcher watches for changes to the chunks collection
 * and invokes a callback when relevant inserts/updates/deletes are detected.
@@ -1553,19 +1597,19 @@ var MongoDBChangeStreamWatcher = class {
 			this.stream.on("error", (err) => {
 				const msg = err.message ?? String(err);
 				if (isChangeStreamNotSupported(msg)) {
-					log$4.info("change streams not supported (standalone topology), closing watcher");
+					log$7.info("change streams not supported (standalone topology), closing watcher");
 					this.close();
-				} else log$4.warn(`change stream error: ${msg}`);
+				} else log$7.warn(`change stream error: ${msg}`);
 			});
-			log$4.info("change stream started");
+			log$7.info("change stream started");
 			return true;
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
 			if (isChangeStreamNotSupported(msg)) {
-				log$4.info("change streams not supported (standalone topology)");
+				log$7.info("change streams not supported (standalone topology)");
 				return false;
 			}
-			log$4.warn(`failed to start change stream: ${msg}`);
+			log$7.warn(`failed to start change stream: ${msg}`);
 			return false;
 		}
 	}
@@ -1602,7 +1646,7 @@ var MongoDBChangeStreamWatcher = class {
 			});
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			log$4.warn(`change stream callback error: ${msg}`);
+			log$7.warn(`change stream callback error: ${msg}`);
 		}
 	}
 	async close() {
@@ -1618,7 +1662,7 @@ var MongoDBChangeStreamWatcher = class {
 			} catch {}
 			this.stream = null;
 		}
-		log$4.info("change stream closed");
+		log$7.info("change stream closed");
 	}
 	get isActive() {
 		return this.stream !== null && !this.closed;
@@ -1629,7 +1673,7 @@ function isChangeStreamNotSupported(msg) {
 }
 //#endregion
 //#region src/memory/mongodb-derived-memory.ts
-const log$3 = createSubsystemLogger("memory:mongodb:derived");
+const log$6 = createSubsystemLogger("memory:mongodb:derived");
 const STOPWORDS = new Set([
 	"a",
 	"an",
@@ -1894,7 +1938,7 @@ async function promoteDerivedMemoryFromEvent(params) {
 				durationMs: 0
 			}
 		}).catch(() => {});
-		log$3.warn(`structured promotion failed for ${event.eventId}: ${String(err)}`);
+		log$6.warn(`structured promotion failed for ${event.eventId}: ${String(err)}`);
 	}
 	try {
 		for (const candidate of extractProcedureCandidatesFromEvent(event)) if ((await writeProcedure({
@@ -1927,7 +1971,7 @@ async function promoteDerivedMemoryFromEvent(params) {
 				durationMs: 0
 			}
 		}).catch(() => {});
-		log$3.warn(`procedure promotion failed for ${event.eventId}: ${String(err)}`);
+		log$6.warn(`procedure promotion failed for ${event.eventId}: ${String(err)}`);
 	}
 	return {
 		structuredCreated,
@@ -1935,6 +1979,696 @@ async function promoteDerivedMemoryFromEvent(params) {
 	};
 }
 //#endregion
+//#region src/memory/mongodb-profile.ts
+const log$5 = createSubsystemLogger("memory:mongodb:profile");
+/**
+* Synthesize a dynamic agent profile from structured memory, entities,
+* episodes, and events. Read-only aggregation across 5 collections.
+*
+* Uses $facet for structured_mem (single pass), $lookup + $group for
+* entity relation counts, simple find for episodes, and $group for
+* event activity patterns.
+*/
+async function synthesizeProfile(params) {
+	const profileStart = Date.now();
+	const { db, prefix, agentId, scope, scopeRef, maxPerType = 20, maxEntities = 10, maxEpisodes = 10, activityWindowMs = 720 * 60 * 60 * 1e3 } = params;
+	const scopeFilter = {
+		agentId,
+		scope,
+		scopeRef
+	};
+	async function settled(label, fn) {
+		try {
+			return await fn();
+		} catch (err) {
+			log$5.warn(`synthesizeProfile: ${label} query failed`, { error: err });
+			return null;
+		}
+	}
+	try {
+		const [structuredResults, entityResults, episodeResults, activityResults] = await Promise.all([
+			settled("structured", () => structuredMemCollection(db, prefix).aggregate([{ $match: {
+				...scopeFilter,
+				state: "active"
+			} }, { $facet: {
+				preferences: [
+					{ $match: { type: "preference" } },
+					{ $sort: { updatedAt: -1 } },
+					{ $limit: maxPerType },
+					{ $project: {
+						key: 1,
+						value: 1,
+						salience: 1,
+						updatedAt: 1
+					} }
+				],
+				decisions: [
+					{ $match: { type: "decision" } },
+					{ $sort: { updatedAt: -1 } },
+					{ $limit: maxPerType },
+					{ $project: {
+						key: 1,
+						value: 1,
+						salience: 1,
+						updatedAt: 1
+					} }
+				],
+				facts: [
+					{ $match: { type: "fact" } },
+					{ $sort: { updatedAt: -1 } },
+					{ $limit: maxPerType },
+					{ $project: {
+						key: 1,
+						value: 1,
+						salience: 1,
+						updatedAt: 1
+					} }
+				],
+				todos: [
+					{ $match: { type: "todo" } },
+					{ $sort: { updatedAt: -1 } },
+					{ $limit: maxPerType },
+					{ $project: {
+						key: 1,
+						value: 1,
+						salience: 1,
+						updatedAt: 1
+					} }
+				]
+			} }]).toArray()),
+			settled("entities", () => entitiesCollection(db, prefix).aggregate([
+				{ $match: scopeFilter },
+				{ $lookup: {
+					from: `${prefix}relations`,
+					let: { eid: "$entityId" },
+					pipeline: [{ $match: {
+						$expr: { $eq: ["$fromEntityId", "$$eid"] },
+						...scopeFilter
+					} }, { $count: "cnt" }],
+					as: "outRels"
+				} },
+				{ $lookup: {
+					from: `${prefix}relations`,
+					let: { eid: "$entityId" },
+					pipeline: [{ $match: {
+						$expr: { $eq: ["$toEntityId", "$$eid"] },
+						...scopeFilter
+					} }, { $count: "cnt" }],
+					as: "inRels"
+				} },
+				{ $addFields: { relationCount: { $add: [{ $ifNull: [{ $arrayElemAt: ["$outRels.cnt", 0] }, 0] }, { $ifNull: [{ $arrayElemAt: ["$inRels.cnt", 0] }, 0] }] } } },
+				{ $sort: { relationCount: -1 } },
+				{ $limit: maxEntities },
+				{ $project: {
+					name: 1,
+					type: 1,
+					relationCount: 1
+				} }
+			]).toArray()),
+			settled("episodes", () => episodesCollection(db, prefix).find(scopeFilter).sort({ "timeRange.start": -1 }).limit(maxEpisodes).project({
+				title: 1,
+				summary: 1,
+				type: 1,
+				timeRange: 1
+			}).toArray()),
+			settled("activity", () => {
+				const activitySince = new Date(Date.now() - activityWindowMs);
+				return eventsCollection(db, prefix).aggregate([{ $match: {
+					...scopeFilter,
+					timestamp: { $gte: activitySince }
+				} }, { $group: {
+					_id: "$role",
+					count: { $sum: 1 },
+					lastTs: { $max: "$timestamp" }
+				} }]).toArray();
+			})
+		]);
+		const structured = structuredResults?.[0] ?? {
+			preferences: [],
+			decisions: [],
+			facts: [],
+			todos: []
+		};
+		const roleDistribution = {};
+		let totalEvents = 0;
+		let lastActive = null;
+		for (const r of activityResults ?? []) {
+			roleDistribution[r._id] = r.count;
+			totalEvents += r.count;
+			const ts = r.lastTs;
+			if (!lastActive || ts > lastActive) lastActive = ts;
+		}
+		const durationMs = Date.now() - profileStart;
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "profile-synthesis"
+			},
+			durationMs,
+			ok: true,
+			resultCount: totalEvents
+		});
+		log$5.info("profile synthesis complete", {
+			agentId,
+			durationMs,
+			totalEvents
+		});
+		return {
+			agentId,
+			scope,
+			scopeRef,
+			preferences: mapMemoryItems(structured.preferences),
+			decisions: mapMemoryItems(structured.decisions),
+			facts: mapMemoryItems(structured.facts),
+			todos: mapMemoryItems(structured.todos),
+			topEntities: (entityResults ?? []).map((e) => ({
+				name: e.name,
+				type: e.type,
+				relationCount: e.relationCount
+			})),
+			recentEpisodes: (episodeResults ?? []).map((e) => ({
+				title: e.title,
+				summary: e.summary,
+				type: e.type,
+				timeRange: e.timeRange
+			})),
+			activityPatterns: {
+				roleDistribution,
+				totalEvents,
+				lastActive
+			},
+			synthesizedAt: /* @__PURE__ */ new Date()
+		};
+	} catch (err) {
+		log$5.error("synthesizeProfile failed", {
+			agentId,
+			error: err
+		});
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "profile-synthesis"
+			},
+			durationMs: Date.now() - profileStart,
+			ok: false
+		});
+		throw err;
+	}
+}
+function mapMemoryItems(items) {
+	return items.map((i) => ({
+		key: i.key,
+		value: i.value,
+		salience: i.salience ?? "normal",
+		updatedAt: i.updatedAt
+	}));
+}
+//#endregion
+//#region src/memory/mongodb-query-cache.ts
+const log$4 = createSubsystemLogger("memory:mongodb:query-cache");
+/** Normalize query for consistent hashing: lowercase, collapse whitespace, trim. */
+function normalizeQuery(query) {
+	return query.toLowerCase().replace(/\s+/g, " ").trim();
+}
+/** SHA-256 hash of normalized query string. */
+function hashQuery(normalizedQuery) {
+	return createHash("sha256").update(normalizedQuery).digest("hex");
+}
+/**
+* Two-tier cache check:
+* Tier 1: Exact SHA-256 hash match via findOne on unique index.
+* Tier 2: $vectorSearch with autoEmbed on queryNorm field, cosine >= threshold.
+*
+* On hit: increments hitCount and updates lastHitAt (fire-and-forget).
+*/
+async function checkCache(params) {
+	const { db, prefix, query, agentId, scope, scopeRef, config } = params;
+	if (!config.enabled) return {
+		hit: false,
+		tier: "miss",
+		results: []
+	};
+	const normalized = normalizeQuery(query);
+	if (!normalized) return {
+		hit: false,
+		tier: "miss",
+		results: []
+	};
+	const cacheStart = Date.now();
+	const col = queryCacheCollection(db, prefix);
+	const qHash = hashQuery(normalized);
+	const now = /* @__PURE__ */ new Date();
+	try {
+		const exact = await col.findOne({
+			queryHash: qHash,
+			agentId,
+			scope,
+			scopeRef,
+			expiresAt: { $gt: now }
+		});
+		if (exact) {
+			col.findOneAndUpdate({ _id: exact._id }, {
+				$inc: { hitCount: 1 },
+				$set: { lastHitAt: now }
+			}).catch((err) => {
+				log$4.warn("cache hit count update failed", { error: err });
+			});
+			emitTelemetry(db, prefix, {
+				meta: {
+					agentId,
+					operation: "cache-check"
+				},
+				durationMs: Date.now() - cacheStart,
+				ok: true,
+				cacheHit: true
+			});
+			return {
+				hit: true,
+				tier: "exact",
+				results: exact.results,
+				pathUsed: exact.pathUsed,
+				sourceScope: exact.sourceScope
+			};
+		}
+	} catch (err) {
+		log$4.warn("cache exact lookup failed", { error: err });
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "cache-check"
+			},
+			durationMs: Date.now() - cacheStart,
+			ok: false,
+			cacheHit: false
+		});
+		return {
+			hit: false,
+			tier: "miss",
+			results: []
+		};
+	}
+	try {
+		const vsStage = buildVectorSearchStage({
+			queryVector: null,
+			queryText: normalized,
+			embeddingMode: "automated",
+			indexName: params.vectorIndexName ?? `${prefix}query_cache_vector`,
+			numCandidates: 20,
+			limit: 1,
+			filter: {
+				agentId,
+				scope,
+				scopeRef
+			},
+			textFieldPath: "queryNorm"
+		});
+		if (!vsStage) {
+			emitTelemetry(db, prefix, {
+				meta: {
+					agentId,
+					operation: "cache-check"
+				},
+				durationMs: Date.now() - cacheStart,
+				ok: true,
+				cacheHit: false
+			});
+			return {
+				hit: false,
+				tier: "miss",
+				results: []
+			};
+		}
+		const pipeline = [
+			{ $vectorSearch: vsStage },
+			{ $limit: 1 },
+			{ $project: {
+				_id: 1,
+				results: 1,
+				pathUsed: 1,
+				sourceScope: 1,
+				expiresAt: 1,
+				score: { $meta: "vectorSearchScore" }
+			} }
+		];
+		const candidates = await col.aggregate(pipeline).toArray();
+		if (candidates.length > 0 && candidates[0].score >= config.similarityThreshold && candidates[0].expiresAt > now) {
+			const match = candidates[0];
+			col.findOneAndUpdate({ _id: match._id }, {
+				$inc: { hitCount: 1 },
+				$set: { lastHitAt: now }
+			}).catch((err) => {
+				log$4.warn("cache hit count update failed (semantic)", { error: err });
+			});
+			emitTelemetry(db, prefix, {
+				meta: {
+					agentId,
+					operation: "cache-check"
+				},
+				durationMs: Date.now() - cacheStart,
+				ok: true,
+				cacheHit: true
+			});
+			return {
+				hit: true,
+				tier: "semantic",
+				results: match.results,
+				pathUsed: match.pathUsed,
+				sourceScope: match.sourceScope
+			};
+		}
+	} catch (err) {
+		log$4.warn("cache semantic lookup failed", { error: err });
+	}
+	emitTelemetry(db, prefix, {
+		meta: {
+			agentId,
+			operation: "cache-check"
+		},
+		durationMs: Date.now() - cacheStart,
+		ok: true,
+		cacheHit: false
+	});
+	return {
+		hit: false,
+		tier: "miss",
+		results: []
+	};
+}
+/**
+* Write search results to cache. Fire-and-forget: does not block caller.
+* Uses upsert to handle race conditions (two identical queries completing simultaneously).
+*/
+function writeCache(params) {
+	const { db, prefix, query, agentId, scope, scopeRef, results, pathUsed, sourceScope, ttlSec } = params;
+	const normalized = normalizeQuery(query);
+	if (!normalized || results.length === 0) return;
+	const now = /* @__PURE__ */ new Date();
+	const expiresAt = new Date(now.getTime() + ttlSec * 1e3);
+	const qHash = hashQuery(normalized);
+	queryCacheCollection(db, prefix).updateOne({
+		queryHash: qHash,
+		agentId,
+		scope,
+		scopeRef
+	}, {
+		$setOnInsert: {
+			queryNorm: normalized,
+			createdAt: now,
+			hitCount: 0
+		},
+		$set: {
+			results,
+			pathUsed,
+			sourceScope,
+			expiresAt,
+			lastHitAt: now
+		}
+	}, { upsert: true }).catch((err) => {
+		log$4.warn("cache write failed", { error: err });
+	});
+}
+//#endregion
+//#region src/memory/mongodb-query-rewriter.ts
+/**
+* Domain-specific synonym map for agent memory queries.
+* Bidirectional: each key expands to its values.
+*/
+const SYNONYM_MAP = {
+	auth: [
+		"authentication",
+		"login",
+		"oauth"
+	],
+	db: [
+		"database",
+		"mongodb",
+		"collection"
+	],
+	bug: [
+		"issue",
+		"error",
+		"defect"
+	],
+	perf: [
+		"performance",
+		"latency",
+		"speed"
+	],
+	config: [
+		"configuration",
+		"settings",
+		"options"
+	],
+	deps: [
+		"dependencies",
+		"packages",
+		"modules"
+	],
+	deploy: [
+		"deployment",
+		"release",
+		"publish"
+	],
+	docs: [
+		"documentation",
+		"readme",
+		"guide"
+	],
+	test: [
+		"testing",
+		"tests",
+		"spec"
+	],
+	refactor: [
+		"restructure",
+		"reorganize",
+		"cleanup"
+	]
+};
+/** Abbreviation expansions (unidirectional: abbreviation -> full form) */
+const ABBREVIATION_MAP = {
+	ts: "typescript",
+	js: "javascript",
+	py: "python",
+	env: "environment",
+	var: "variable",
+	fn: "function",
+	cb: "callback",
+	req: "request",
+	res: "response",
+	err: "error",
+	msg: "message",
+	ctx: "context",
+	impl: "implementation",
+	repo: "repository"
+};
+/**
+* Deterministic synonym expansion.
+* For each word in the query:
+*   1. Check if it is an abbreviation -- add full form
+*   2. Check if it matches a synonym group -- add all synonyms
+* Original words are always preserved.
+*/
+function expandSynonyms(query) {
+	const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+	const expanded = new Set(words);
+	const maxTotal = words.length * 3;
+	for (const word of words) {
+		const abbr = ABBREVIATION_MAP[word];
+		if (abbr && expanded.size < maxTotal) expanded.add(abbr);
+		const syns = SYNONYM_MAP[word];
+		if (syns) for (const syn of syns) {
+			if (expanded.size >= maxTotal) break;
+			expanded.add(syn);
+		}
+	}
+	return [...expanded].join(" ");
+}
+/**
+* Rewrite a query for improved vector search recall.
+*
+* CRITICAL: The retrieval planner must ALWAYS see the ORIGINAL query.
+* This function is called AFTER planRetrieval() and BEFORE search execution.
+* The cache key must also use the ORIGINAL query.
+*
+* Tier 1 (synonym-expansion): Deterministic, zero latency.
+*   - Expand known abbreviations
+*   - Add synonyms for recognized terms
+*   - Preserve original terms (expansion, not replacement)
+*/
+async function rewriteQuery(params) {
+	const { db, prefix, agentId, query, config } = params;
+	const rewriteStart = Date.now();
+	if (!config.enabled || !query.trim()) return {
+		originalQuery: query,
+		rewrittenQuery: query,
+		rewritten: false,
+		method: "none"
+	};
+	let rewritten;
+	let method;
+	switch (config.method) {
+		case "synonym-expansion":
+			rewritten = expandSynonyms(query);
+			method = "synonym-expansion";
+			break;
+		case "llm":
+		case "hyde": throw new Error(`Query rewrite method "${config.method}" is not yet implemented. Use "synonym-expansion" or disable query rewriting (queryRewriting.enabled: false).`);
+		default:
+			rewritten = query;
+			method = "none";
+	}
+	const wasRewritten = rewritten !== query;
+	if (wasRewritten) {
+		const maxChars = config.maxTokens * 4;
+		if (rewritten.length > maxChars) rewritten = rewritten.slice(0, maxChars).trimEnd();
+	}
+	emitTelemetry(db, prefix, {
+		meta: {
+			agentId,
+			operation: "query-rewrite"
+		},
+		durationMs: Date.now() - rewriteStart,
+		ok: true,
+		queryRewritten: wasRewritten,
+		rewriteMethod: method
+	});
+	return {
+		originalQuery: query,
+		rewrittenQuery: rewritten,
+		rewritten: wasRewritten,
+		method
+	};
+}
+//#endregion
+//#region src/memory/mongodb-reranker.ts
+const log$3 = createSubsystemLogger("memory:mongodb:reranker");
+const VOYAGE_RERANK_URL_ATLAS = "https://ai.mongodb.com/v1/rerank";
+const VOYAGE_RERANK_URL_DIRECT = "https://api.voyageai.com/v1/rerank";
+function resolveRerankUrl(apiKey) {
+	return apiKey.startsWith("al-") ? VOYAGE_RERANK_URL_ATLAS : VOYAGE_RERANK_URL_DIRECT;
+}
+/**
+* Cross-encoder re-ranking of search results using Voyage rerank-2.5 API.
+*
+* On ANY error (network, API, JSON parse, unexpected shape): falls back to
+* input order unchanged, logs a warning, and never crashes the search pipeline.
+*
+* Uses `r.snippet` for document text (MemorySearchResult has no `text` field).
+*/
+async function crossEncoderRerank(params) {
+	const { db, prefix, agentId, query, results, config } = params;
+	const rerankStart = Date.now();
+	if (!config.enabled || results.length === 0 || !config.voyageApiKey) return {
+		results,
+		reranked: false,
+		latencyMs: 0
+	};
+	const aboveMinScore = results.filter((r) => r.score >= config.minScore);
+	const candidates = aboveMinScore.slice(0, config.topN);
+	const overflow = aboveMinScore.slice(config.topN);
+	const below = results.filter((r) => r.score < config.minScore);
+	if (candidates.length <= 1) return {
+		results,
+		reranked: false,
+		latencyMs: 0
+	};
+	try {
+		const validCandidates = candidates.filter((r) => r.snippet.trim().length > 0);
+		const emptySnippetCandidates = candidates.filter((r) => r.snippet.trim().length === 0);
+		if (validCandidates.length <= 1) return {
+			results,
+			reranked: false,
+			latencyMs: 0
+		};
+		const documents = validCandidates.map((r) => r.snippet);
+		const rerankUrl = resolveRerankUrl(config.voyageApiKey);
+		const response = await fetch(rerankUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${config.voyageApiKey}`
+			},
+			body: JSON.stringify({
+				model: config.model,
+				query: config.instruction ? `${config.instruction}\n${query}` : query,
+				documents,
+				top_k: validCandidates.length
+			}),
+			signal: AbortSignal.timeout(2e3)
+		});
+		if (!response.ok) {
+			log$3.warn("rerank API returned non-OK status", { status: response.status });
+			return {
+				results,
+				reranked: false,
+				latencyMs: Date.now() - rerankStart
+			};
+		}
+		const body = await response.json();
+		if (!body.data || !Array.isArray(body.data)) {
+			log$3.warn("rerank API returned unexpected response shape");
+			return {
+				results,
+				reranked: false,
+				latencyMs: Date.now() - rerankStart
+			};
+		}
+		const reranked = body.data.filter((r) => {
+			if (typeof r.index !== "number" || r.index < 0 || r.index >= validCandidates.length) {
+				log$3.warn("rerank API returned out-of-bounds index", {
+					index: r.index,
+					max: validCandidates.length - 1
+				});
+				return false;
+			}
+			return true;
+		}).toSorted((a, b) => b.relevance_score - a.relevance_score).map((r) => ({
+			...validCandidates[r.index],
+			score: Math.min(1, Math.max(0, r.relevance_score))
+		}));
+		const latencyMs = Date.now() - rerankStart;
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "rerank"
+			},
+			durationMs: latencyMs,
+			ok: true,
+			resultCount: reranked.length,
+			rerankModel: config.model,
+			rerankLatencyMs: latencyMs
+		});
+		return {
+			results: [
+				...reranked,
+				...emptySnippetCandidates,
+				...overflow,
+				...below
+			],
+			reranked: true,
+			latencyMs
+		};
+	} catch (err) {
+		log$3.warn("rerank failed, falling back to input order", { error: err });
+		emitTelemetry(db, prefix, {
+			meta: {
+				agentId,
+				operation: "rerank"
+			},
+			durationMs: Date.now() - rerankStart,
+			ok: false,
+			rerankModel: config.model,
+			rerankLatencyMs: Date.now() - rerankStart
+		});
+		return {
+			results,
+			reranked: false,
+			latencyMs: Date.now() - rerankStart
+		};
+	}
+}
+//#endregion
 //#region src/memory/session-files.ts
 const log$2 = createSubsystemLogger("memory");
 async function listSessionFilesForAgent(agentId) {
@@ -2685,7 +3419,8 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 	buildConversationChunkFilter() {
 		return {
 			source: { $in: ["conversation", "sessions"] },
-			agentId: this.agentId
+			agentId: this.agentId,
+			status: { $ne: "deleted" }
 		};
 	}
 	buildBridgeChunkFilter() {
@@ -2693,7 +3428,8 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 			source: { $in: ["conversation", "memory"] },
 			agentId: this.agentId,
 			scope: "workspace",
-			scopeRef: this.workspaceScopeRef
+			scopeRef: this.workspaceScopeRef,
+			status: { $ne: "deleted" }
 		};
 	}
 	getBridgeChunkBudget(maxResults) {
@@ -2868,6 +3604,25 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 		const minScore = opts?.minScore ?? .1;
 		const activeSources = getActiveSources(mongoCfg.sources, mongoCfg.kb.enabled);
 		const availablePaths = this.buildV2AvailablePaths(activeSources);
+		if (mongoCfg.cache.enabled) {
+			const cacheResult = await checkCache({
+				db: this.db,
+				prefix: this.prefix,
+				query: cleaned,
+				agentId: this.agentId,
+				scope: "agent",
+				scopeRef: this.agentScopeRef,
+				config: mongoCfg.cache
+			});
+			if (cacheResult.hit) {
+				this.setLastSearchMode(`v2:cache:${cacheResult.tier}`, {
+					pathUsed: cacheResult.pathUsed,
+					sourceScope: cacheResult.sourceScope
+				});
+				return cacheResult.results;
+			}
+		}
+		const searchStart = Date.now();
 		try {
 			const v2 = await searchV2(this.db, this.prefix, cleaned, this.agentId, {
 				availablePaths,
@@ -2885,9 +3640,23 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 					bridgeFilter: activeSources.conversation ? this.buildBridgeChunkFilter() : void 0,
 					bridgeMaxResults: this.getBridgeChunkBudget(maxResults),
 					scope: "agent",
-					scopeRef: this.agentScopeRef
+					scopeRef: this.agentScopeRef,
+					rerankConfig: mongoCfg.reranking,
+					queryRewriteConfig: mongoCfg.queryRewriting
 				}
 			});
+			emitTelemetry(this.db, this.prefix, {
+				meta: {
+					agentId: this.agentId,
+					operation: "search"
+				},
+				durationMs: Date.now() - searchStart,
+				ok: v2.results.length > 0,
+				pathUsed: v2.metadata.pathsExecuted.join(","),
+				resultCount: v2.results.length,
+				topScore: v2.results[0]?.score ?? 0,
+				fusionMethod: mongoCfg.fusionMethod
+			});
 			const v2Details = {
 				plan: v2.metadata.plan.paths,
 				confidence: v2.metadata.plan.confidence,
@@ -2897,6 +3666,21 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 			};
 			if (v2.results.length > 0) {
 				this.setLastSearchMode("v2", v2Details);
+				if (mongoCfg.cache.enabled) {
+					const ttlSec = v2.metadata.pathsExecuted.includes("kb") ? mongoCfg.cache.kbTtlSec : mongoCfg.cache.conversationTtlSec;
+					writeCache({
+						db: this.db,
+						prefix: this.prefix,
+						query: cleaned,
+						agentId: this.agentId,
+						scope: "agent",
+						scopeRef: this.agentScopeRef,
+						results: v2.results,
+						pathUsed: v2.metadata.pathsExecuted.join(","),
+						sourceScope: "conversation",
+						ttlSec
+					});
+				}
 				return v2.results;
 			}
 			const fallbackResults = await this.legacySearch(cleaned, opts);
@@ -3557,7 +4341,8 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 		const { rawPath, episodeId, expandEvents } = params;
 		const episode = await episodesCollection(this.db, this.prefix).findOne({
 			agentId: this.agentId,
-			episodeId
+			episodeId,
+			status: { $ne: "deleted" }
 		});
 		if (!episode) return {
 			text: "",
@@ -3693,7 +4478,7 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 		if (hoursSinceRefresh < autoRefreshHours) return;
 		log.info(`KB auto-refresh: ${hoursSinceRefresh.toFixed(1)}h since last import, refreshing ${paths.length} paths`);
 		try {
-			const { ingestFilesToKB } = await import("./mongodb-kb-C-VmGOq7.js");
+			const { ingestFilesToKB } = await import("./mongodb-kb-1tSOXXb9.js");
 			const result = await ingestFilesToKB({
 				db: this.db,
 				prefix: this.prefix,
@@ -3713,12 +4498,7 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 	ensureWatcher() {
 		if (this.watcher) return;
 		const debounceMs = this.config.mongodb.watchDebounceMs;
-		const watchPaths = new Set([
-			path.join(this.workspaceDir, "MEMORY.md"),
-			path.join(this.workspaceDir, "memory.md"),
-			path.join(this.workspaceDir, "memory"),
-			...this.extraMemoryPaths
-		]);
+		const watchPaths = new Set([path.join(this.workspaceDir, "memory"), ...this.extraMemoryPaths]);
 		this.watcher = chokidar.watch(Array.from(watchPaths), {
 			ignoreInitial: true,
 			awaitWriteFinish: {
@@ -3773,7 +4553,7 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 	}
 	async writeStructuredMemory(entry) {
 		const mongoCfg = this.config.mongodb;
-		const { writeStructuredMemory: writeFn } = await import("./mongodb-structured-memory-BySGexcm.js");
+		const { writeStructuredMemory: writeFn } = await import("./mongodb-structured-memory-lpyyW0kn.js");
 		return writeFn({
 			db: this.db,
 			prefix: this.prefix,
@@ -3787,7 +4567,7 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 	}
 	async writeProcedure(entry) {
 		const mongoCfg = this.config.mongodb;
-		const { writeProcedure: writeFn } = await import("./mongodb-procedures-D3M2Ph8E.js");
+		const { writeProcedure: writeFn } = await import("./mongodb-procedures-tjhGdBV7.js");
 		return writeFn({
 			db: this.db,
 			prefix: this.prefix,
@@ -3802,6 +4582,19 @@ var MongoDBMemoryManager = class MongoDBMemoryManager {
 	async getDetailedStatus() {
 		return getV2Status(this.db, this.prefix, this.agentId);
 	}
+	async synthesizeProfile(params = {}) {
+		return synthesizeProfile({
+			db: this.db,
+			prefix: this.prefix,
+			agentId: this.agentId,
+			scope: params.scope ?? "agent",
+			scopeRef: params.scopeRef ?? this.agentScopeRef,
+			maxPerType: params.maxPerType,
+			maxEntities: params.maxEntities,
+			maxEpisodes: params.maxEpisodes,
+			activityWindowMs: params.activityWindowMs
+		});
+	}
 	enqueueDerivedWork(task) {
 		const run = async () => {
 			try {
@@ -4016,7 +4809,8 @@ async function searchV2(db, prefix, query, agentId, context) {
 		});
 		const conversationChunkFilter = context.searchOptions?.conversationFilter ?? {
 			source: { $in: ["conversation", "sessions"] },
-			agentId
+			agentId,
+			status: { $ne: "deleted" }
 		};
 		const bridgeChunkFilter = context.searchOptions?.bridgeFilter;
 		const maxResults = context.maxResults ?? 20;
@@ -4038,6 +4832,22 @@ async function searchV2(db, prefix, query, agentId, context) {
 			hasEpisodes: context.hasEpisodes,
 			hasGraphData: context.hasGraphData
 		});
+		const qrConfig = context.searchOptions?.queryRewriteConfig;
+		let searchQuery = query;
+		let wasQueryRewritten = false;
+		if (qrConfig?.enabled) {
+			const rewriteResult = await rewriteQuery({
+				db,
+				prefix,
+				agentId,
+				query,
+				config: qrConfig
+			});
+			if (rewriteResult.rewritten) {
+				searchQuery = rewriteResult.rewrittenQuery;
+				wasQueryRewritten = true;
+			}
+		}
 		const constrainedGraphCandidates = plan.constraints?.entities?.names && plan.constraints.entities.names.length > 0 ? plan.constraints.entities.names : graphQueryCandidates;
 		const timeRange = plan.constraints?.timeRange ? resolveTimeRangePreset(plan.constraints.timeRange.preset) : void 0;
 		const structuredFilter = {
@@ -4058,12 +4868,13 @@ async function searchV2(db, prefix, query, agentId, context) {
 		const results = [];
 		const pathsExecuted = [];
 		const resultsByPath = {};
+		const perPathResults = {};
 		const pathsToExecute = plan.paths.slice(0, 3);
 		for (const path of pathsToExecute) try {
 			let pathResults = [];
 			switch (path) {
 				case "active-critical":
-					pathResults = await searchStructuredMemory(structuredMemCollection(db, prefix), query, null, {
+					pathResults = await searchStructuredMemory(structuredMemCollection(db, prefix), searchQuery, null, {
 						maxResults: context.maxResults ?? 10,
 						minScore,
 						filter: activeCriticalFilter,
@@ -4077,7 +4888,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 					});
 					break;
 				case "structured":
-					pathResults = await searchStructuredMemory(structuredMemCollection(db, prefix), query, null, {
+					pathResults = await searchStructuredMemory(structuredMemCollection(db, prefix), searchQuery, null, {
 						maxResults: context.maxResults ?? 10,
 						minScore,
 						filter: structuredFilter,
@@ -4098,7 +4909,8 @@ async function searchV2(db, prefix, query, agentId, context) {
 						start: timeRange?.start ?? /* @__PURE__ */ new Date(Date.now() - 1440 * 60 * 1e3),
 						end: timeRange?.end ?? /* @__PURE__ */ new Date(),
 						scope,
-						scopeRef: agentScopeRef
+						scopeRef: agentScopeRef,
+						limit: 50
 					})].toSorted((a, b) => b.timestamp.getTime() - a.timestamp.getTime()).map((e, i) => ({
 						path: `events/${e.eventId}`,
 						filePath: `events/${e.eventId}`,
@@ -4135,7 +4947,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 								startLine: 0,
 								endLine: 0,
 								snippet: `${graph.rootEntity.name} ${c.relation.type} ${c.entity.name}`,
-								score: Math.max(.25, .9 - c.depth * .08 - i * .02 - (4 - graphRelationPriority(c.relation.type)) * .05) + Math.min(c.relation.weight ?? 0, .15),
+								score: Math.min(1, Math.max(.25, .9 - c.depth * .08 - i * .02 - (4 - graphRelationPriority(c.relation.type)) * .05) + Math.min(c.relation.weight ?? 0, .15)),
 								source: "conversation"
 							}));
 						}
@@ -4161,7 +4973,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 					}));
 					break;
 				case "procedural":
-					pathResults = await searchProcedures(proceduresCollection(db, prefix), query, null, {
+					pathResults = await searchProcedures(proceduresCollection(db, prefix), searchQuery, null, {
 						maxResults: context.maxResults ?? 10,
 						minScore,
 						filter: proceduralFilter,
@@ -4176,7 +4988,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 					break;
 				case "hybrid": {
 					const searches = [];
-					if (conversationChunkFilter) searches.push(mongoSearch(chunksCollection(db, prefix), query, null, {
+					if (conversationChunkFilter) searches.push(mongoSearch(chunksCollection(db, prefix), searchQuery, null, {
 						maxResults: context.maxResults ?? 10,
 						minScore,
 						numCandidates,
@@ -4193,7 +5005,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 						log.warn(`searchV2 hybrid conversation path failed: ${String(err)}`);
 						return [];
 					}));
-					if (bridgeChunkFilter) searches.push(mongoSearch(chunksCollection(db, prefix), query, null, {
+					if (bridgeChunkFilter) searches.push(mongoSearch(chunksCollection(db, prefix), searchQuery, null, {
 						maxResults: bridgeMaxResults,
 						minScore,
 						numCandidates,
@@ -4214,7 +5026,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 					break;
 				}
 				case "kb":
-					pathResults = await searchKB(kbChunksCollection(db, prefix), query, null, {
+					pathResults = await searchKB(kbChunksCollection(db, prefix), searchQuery, null, {
 						maxResults: Math.max(3, Math.floor((context.maxResults ?? 10) / 3)),
 						minScore,
 						...kbFilter ? { filter: kbFilter } : {},
@@ -4233,6 +5045,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 			if (pathResults.length > 0) {
 				pathsExecuted.push(path);
 				resultsByPath[path] = pathResults.length;
+				perPathResults[path] = pathResults;
 				results.push(...pathResults);
 			}
 		} catch (pathErr) {
@@ -4240,7 +5053,7 @@ async function searchV2(db, prefix, query, agentId, context) {
 		}
 		let deduped = deduplicateSearchResults(results);
 		if (context.availablePaths.has("procedural") && !pathsToExecute.includes("procedural") && deduped.length < Math.max(2, Math.ceil(maxResults / 3))) try {
-			const procedureFallback = await searchProcedures(proceduresCollection(db, prefix), query, null, {
+			const procedureFallback = await searchProcedures(proceduresCollection(db, prefix), searchQuery, null, {
 				maxResults: context.maxResults ?? 10,
 				minScore,
 				filter: proceduralFilter,
@@ -4252,35 +5065,74 @@ async function searchV2(db, prefix, query, agentId, context) {
 			if (procedureFallback.length > 0) {
 				pathsExecuted.push("procedural");
 				resultsByPath.procedural = procedureFallback.length;
+				perPathResults.procedural = procedureFallback;
 				deduped = deduplicateSearchResults([...deduped, ...procedureFallback]);
 			}
 		} catch (err) {
 			log.warn(`searchV2 procedural backstop failed: ${String(err)}`);
 		}
 		if (allowHybridBackstop && context.availablePaths.has("hybrid") && !pathsExecuted.includes("hybrid") && deduped.length < Math.max(2, Math.ceil(maxResults / 3))) try {
-			const fallback = await searchV2(db, prefix, query, agentId, {
+			const fallback = await searchV2(db, prefix, searchQuery, agentId, {
 				...context,
 				availablePaths: new Set(["hybrid"]),
 				maxResults,
 				searchOptions: {
 					...context.searchOptions,
-					allowHybridBackstop: false
+					allowHybridBackstop: false,
+					queryRewriteConfig: void 0
 				}
 			});
 			if (fallback.results.length > 0) {
 				pathsExecuted.push("hybrid");
 				resultsByPath.hybrid = fallback.results.length;
+				perPathResults.hybrid = fallback.results;
 				deduped = deduplicateSearchResults([...deduped, ...fallback.results]);
 			}
 		} catch (err) {
 			log.warn(`searchV2 hybrid backstop failed: ${String(err)}`);
 		}
+		if (Object.keys(perPathResults).length > 1) {
+			const rrfMap = /* @__PURE__ */ new Map();
+			for (const [_pathName, pathRes] of Object.entries(perPathResults)) for (let rank = 0; rank < pathRes.length; rank++) {
+				const key = pathRes[rank].snippet;
+				rrfMap.set(key, (rrfMap.get(key) ?? 0) + rrfScore(rank + 1));
+			}
+			for (const r of deduped) {
+				const rrfVal = rrfMap.get(r.snippet);
+				if (rrfVal !== void 0) r.score = rrfVal;
+			}
+			deduped.sort((a, b) => b.score - a.score);
+		}
+		const heuristicReranked = rerankResults(deduped, query);
+		const rerankCfg = context.searchOptions?.rerankConfig;
+		let finalResults = heuristicReranked;
+		let wasReranked = false;
+		if (rerankCfg?.enabled) {
+			const rerankResult = await crossEncoderRerank({
+				db,
+				prefix,
+				agentId,
+				query,
+				results: heuristicReranked,
+				config: rerankCfg
+			});
+			if (rerankResult.reranked) {
+				finalResults = rerankResult.results;
+				wasReranked = true;
+			}
+		}
+		const sliced = finalResults.slice(0, maxResults);
 		return {
-			results: rerankResults(deduped, query).slice(0, maxResults),
+			results: (context.searchOptions?.projection ?? "full") === "ids-only" ? sliced.map((r) => ({
+				...r,
+				snippet: ""
+			})) : sliced,
 			metadata: {
 				plan,
 				pathsExecuted,
-				resultsByPath
+				resultsByPath,
+				reranked: wasReranked,
+				queryRewritten: wasQueryRewritten
 			}
 		};
 	} catch (err) {