mnemocyte 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
-import { and, desc, eq, gt, inArray, isNotNull, isNull, lt, or, sql } from "drizzle-orm";
+import { and, count, countDistinct, desc, eq, gt, inArray, isNotNull, isNull, lt, or, sql } from "drizzle-orm";
 import { customType, index, integer, jsonb, pgTable, real, text, timestamp } from "drizzle-orm/pg-core";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -54,7 +54,11 @@ const memoriesTable = pgTable("mnemocyte_memories", {
 	accessCount: integer("access_count").notNull().default(0),
 	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
 	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [index("mnemocyte_memories_entity_idx").on(table.entityId), index("mnemocyte_memories_entity_type_idx").on(table.entityId, table.type)]);
+}, (table) => [
+	index("mnemocyte_memories_entity_idx").on(table.entityId),
+	index("mnemocyte_memories_entity_type_idx").on(table.entityId, table.type),
+	index("mnemocyte_memories_embedding_hnsw_idx").using("hnsw", table.embedding.op("vector_cosine_ops"))
+]);
 const eventsTable = pgTable("mnemocyte_events", {
 	id: text("id").primaryKey(),
 	entityId: text("entity_id").notNull(),
@@ -64,11 +68,22 @@ const eventsTable = pgTable("mnemocyte_events", {
 }, (table) => [index("mnemocyte_events_entity_time_idx").on(table.entityId, table.timestamp)]);
 //#endregion
 //#region src/db/index.ts
+function parseSslFromUrl(url) {
+	const mode = url.searchParams.get("sslmode");
+	if (!mode || mode === "disable") return void 0;
+	if (mode === "require" || mode === "prefer" || mode === "allow") return { rejectUnauthorized: false };
+	if (mode === "verify-full") return "verify-full";
+}
 function createDatabase(databaseUrl) {
+	const url = new URL(databaseUrl);
+	const ssl = parseSslFromUrl(url);
+	const isPooler = url.port === "6543" || url.searchParams.get("pgbouncer") === "true";
 	const client = postgres(databaseUrl, {
 		max: 10,
 		idle_timeout: 20,
-		connect_timeout: 10
+		connect_timeout: 10,
+		...ssl ? { ssl } : {},
+		...isPooler ? { prepare: false } : {}
 	});
 	return {
 		db: drizzle(client, { schema: schema_exports }),
@@ -214,11 +229,19 @@ async function buildContext(options) {
 	const maxTokens = options.input.maxTokens ?? 1200;
 	const tokenCounter = options.input.tokenCounter ?? heuristicTokenCounter;
 	const memories = await options.recall(options.input);
-	for (let count = memories.length; count >= 0; count -= 1) {
-		const omittedCount = memories.length - count;
-		const context = formatContext(memories.slice(0, count), options.input.query, format, omittedCount);
-		if (tokenCounter.count(context) <= maxTokens) return context;
+	let low = 0;
+	let high = memories.length;
+	let bestContext = "";
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const omittedCount = memories.length - mid;
+		const context = formatContext(memories.slice(0, mid), options.input.query, format, omittedCount);
+		if (tokenCounter.count(context) <= maxTokens) {
+			bestContext = context;
+			low = mid + 1;
+		} else high = mid - 1;
 	}
+	if (bestContext || memories.length === 0) return bestContext;
 	return trimToTokenBudget(formatContext([], options.input.query, format, memories.length), maxTokens, tokenCounter);
 }
 //#endregion
@@ -481,6 +504,12 @@ function cloneMemory(memory) {
 		updatedAt: new Date(memory.updatedAt)
 	};
 }
+function toDate(value) {
+	return value instanceof Date ? value : new Date(value);
+}
+function toNullableDate(value) {
+	return value === null ? null : toDate(value);
+}
 function rowToMemory(row) {
 	return {
 		id: row.id,
@@ -495,12 +524,12 @@ function rowToMemory(row) {
 		embeddingModel: row.embeddingModel,
 		embeddingDimensions: row.embeddingDimensions,
 		supersededBy: row.supersededBy,
-		supersededAt: row.supersededAt,
-		expiresAt: row.expiresAt,
-		lastAccessedAt: row.lastAccessedAt,
+		supersededAt: toNullableDate(row.supersededAt),
+		expiresAt: toNullableDate(row.expiresAt),
+		lastAccessedAt: toNullableDate(row.lastAccessedAt),
 		accessCount: row.accessCount,
-		createdAt: row.createdAt,
-		updatedAt: row.updatedAt
+		createdAt: toDate(row.createdAt),
+		updatedAt: toDate(row.updatedAt)
 	};
 }
 async function embedOne(embedder, text, options = {}) {
@@ -519,6 +548,22 @@ async function embedOne(embedder, text, options = {}) {
 	if (embedding.length !== embedder.dimensions) throw new MnemocyteError("Embedder returned an embedding with unexpected dimensions.", "EMBEDDING");
 	return embedding;
 }
+async function embedMany(embedder, texts, options = {}) {
+	if (texts.length === 0) return [];
+	let embeddings;
+	try {
+		embeddings = await withResilience((signal) => signal === void 0 ? embedder.embed(texts) : embedder.embed(texts, { signal }), {
+			...options.signal === void 0 ? {} : { signal: options.signal },
+			...options.resilience === void 0 ? {} : { resilience: options.resilience }
+		});
+	} catch (error) {
+		if (error instanceof MnemocyteError && (error.code === "TIMEOUT" || error.code === "ABORTED")) throw error;
+		throw new MnemocyteError("Failed to embed texts.", "EMBEDDING", error);
+	}
+	if (embeddings.length !== texts.length) throw new MnemocyteError(`Embedder returned ${embeddings.length} embeddings for ${texts.length} texts.`, "EMBEDDING");
+	for (const embedding of embeddings) if (embedding.length !== embedder.dimensions) throw new MnemocyteError("Embedder returned an embedding with unexpected dimensions.", "EMBEDDING");
+	return embeddings;
+}
 function validateRememberInput(input) {
 	assertNonEmptyString(input.entityId, "entityId");
 	assertNonEmptyString(input.content, "content");
@@ -657,12 +702,18 @@ function cosineSimilarity(a, b) {
 	if (aMagnitude === 0 || bMagnitude === 0) return 0;
 	return dot / (Math.sqrt(aMagnitude) * Math.sqrt(bMagnitude));
 }
-function lexicalScore(content, query) {
-	const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+function tokenizeQuery(query) {
+	return query.toLowerCase().split(/\s+/).filter(Boolean);
+}
+function lexicalScoreWithTerms(content, terms) {
 	if (terms.length === 0) return 0;
 	const lowerContent = content.toLowerCase();
 	return terms.filter((term) => lowerContent.includes(term)).length / terms.length;
 }
+function createLexicalScorer(query) {
+	const terms = tokenizeQuery(query);
+	return (content) => lexicalScoreWithTerms(content, terms);
+}
 function clampScore(value) {
 	if (!Number.isFinite(value)) return 0;
 	return Math.max(0, Math.min(1, value));
@@ -683,6 +734,13 @@ function normalizeWeights(weights) {
 		importance: merged.importance / total
 	};
 }
+function createScoringConfig(config) {
+	return {
+		weights: normalizeWeights(config?.weights),
+		recencyHalfLifeDays: config?.recencyHalfLifeDays ?? DEFAULT_RECENCY_HALF_LIFE_DAYS,
+		accessSaturation: config?.accessSaturation ?? DEFAULT_ACCESS_SATURATION
+	};
+}
 function recencyScore(createdAt, halfLifeDays) {
 	const ageMs = Date.now() - createdAt.getTime();
 	const ageDays = Math.max(0, ageMs / 864e5);
@@ -692,11 +750,11 @@ function accessScore(accessCount, saturation) {
 	if (accessCount <= 0) return 0;
 	return Math.min(1, Math.log1p(accessCount) / Math.log1p(saturation));
 }
-function toScoredMemory(memory, vector, lexical, input, config) {
-	const weights = normalizeWeights(config?.weights);
-	const recency = recencyScore(memory.createdAt, config?.recencyHalfLifeDays ?? DEFAULT_RECENCY_HALF_LIFE_DAYS);
+function toScoredMemoryWithConfig(memory, vector, lexical, input, config) {
+	const { weights } = config;
+	const recency = recencyScore(memory.createdAt, config.recencyHalfLifeDays);
 	const confidence = clampScore(memory.confidence);
-	const access = accessScore(memory.accessCount, config?.accessSaturation ?? DEFAULT_ACCESS_SATURATION);
+	const access = accessScore(memory.accessCount, config.accessSaturation);
 	const importance = IMPORTANCE_SCORES[memory.importance];
 	const score = Math.max(0, Math.min(1, clampScore(vector) * weights.vector + clampScore(lexical) * weights.lexical + recency * weights.recency + confidence * weights.confidence + access * weights.access + importance * weights.importance));
 	return {
@@ -793,13 +851,50 @@ function createInMemoryClient(config) {
 			count: 1
 		}));
 	}
-	return {
+	const client = {
 		remember,
 		async rememberMany(inputs) {
 			return observe(config, "in-memory", "rememberMany", { count: inputs.length }, async () => {
 				assertOpen();
+				if (inputs.length === 0) return [];
+				for (const input of inputs) validateRememberInput(input);
+				const embeddings = await embedMany(config.embedder, inputs.map((i) => i.content), {
+					...inputs[0]?.signal === void 0 ? {} : { signal: inputs[0].signal },
+					...config.provider === void 0 ? {} : { resilience: config.provider }
+				});
+				const now = /* @__PURE__ */ new Date();
 				const result = [];
-				for (const input of inputs) result.push(await remember(input));
+				for (let i = 0; i < inputs.length; i++) {
+					const input = inputs[i];
+					const memory = {
+						id: createId(),
+						entityId: input.entityId,
+						content: input.content,
+						type: input.type ?? "fact",
+						importance: input.importance ?? "normal",
+						tags: normalizeTags(input.tags),
+						source: input.source ?? null,
+						metadata: input.metadata ?? {},
+						confidence: input.confidence ?? 1,
+						embeddingModel: config.embedder.model,
+						embeddingDimensions: config.embedder.dimensions,
+						supersededBy: null,
+						supersededAt: null,
+						expiresAt: input.expiresAt ?? null,
+						lastAccessedAt: null,
+						accessCount: 0,
+						createdAt: now,
+						updatedAt: now,
+						embedding: embeddings[i]
+					};
+					memories.set(memory.id, memory);
+					recordAudit(memory.entityId, "memory.created", {
+						memoryId: memory.id,
+						type: memory.type,
+						importance: memory.importance
+					});
+					result.push(cloneMemory(memory));
+				}
 				return result;
 			}, (result) => ({ count: result.length }));
 		},
@@ -816,7 +911,9 @@ function createInMemoryClient(config) {
 					...config.provider === void 0 ? {} : { resilience: config.provider }
 				});
 				const now = /* @__PURE__ */ new Date();
-				const scored = Array.from(memories.values()).filter((memory) => matchesRecallFilter(memory, input, now)).map((memory) => toScoredMemory(memory, Math.max(0, cosineSimilarity(memory.embedding, queryEmbedding)), lexicalScore(memory.content, input.query), input, config.retrieval)).filter((memory) => memory.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+				const scoreLexical = createLexicalScorer(input.query);
+				const scoringConfig = createScoringConfig(config.retrieval);
+				const scored = Array.from(memories.values()).filter((memory) => matchesRecallFilter(memory, input, now)).map((memory) => toScoredMemoryWithConfig(memory, Math.max(0, cosineSimilarity(memory.embedding, queryEmbedding)), scoreLexical(memory.content), input, scoringConfig)).filter((memory) => memory.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
 				for (const memory of scored) {
 					const stored = memories.get(memory.id);
 					if (stored) {
@@ -835,7 +932,7 @@ function createInMemoryClient(config) {
 					input,
 					recall: (contextInput) => {
 						const recallInput = contextInputToRecallInput(contextInput);
-						return this.recall(input.signal === void 0 ? recallInput : {
+						return client.recall(input.signal === void 0 ? recallInput : {
 							...recallInput,
 							signal: input.signal
 						});
@@ -969,6 +1066,7 @@ function createInMemoryClient(config) {
 			});
 		}
 	};
+	return client;
 	function createExperimental() {
 		return { async consolidate(input) {
 			return observe(config, "in-memory", "consolidate", {
@@ -1020,7 +1118,7 @@ function createInMemoryClient(config) {
 //#region src/db/queries/events.ts
 async function insertEvent(db, row) {
 	const inserted = (await db.insert(eventsTable).values(row).returning())[0];
-	if (!inserted) throw new Error("Event insert returned no rows.");
+	if (!inserted) throw new MnemocyteError("Event insert returned no rows.", "DB");
 	return inserted;
 }
 async function listEvents(db, filter) {
@@ -1035,19 +1133,70 @@ function formatVectorComponent(value) {
 	if (!Number.isFinite(value)) throw new Error("Vector values must be finite numbers.");
 	return Object.is(value, -0) ? "0" : value.toFixed(17);
 }
-function filterConditions(filter) {
-	return and(eq(memoriesTable.entityId, filter.entityId), filter.includeSuperseded ? void 0 : isNull(memoriesTable.supersededBy), filter.includeExpired ? void 0 : sql`(${memoriesTable.expiresAt} IS NULL OR ${memoriesTable.expiresAt} > now())`, filter.types && filter.types.length > 0 ? inArray(memoriesTable.type, [...filter.types]) : void 0, filter.tags && filter.tags.length > 0 ? sql`${memoriesTable.tags} @> ${filter.tags}` : void 0, filter.before ? lt(memoriesTable.createdAt, filter.before) : void 0, filter.after ? gt(memoriesTable.createdAt, filter.after) : void 0);
+function timestampParam(value) {
+	return sql`${value.toISOString()}::timestamptz`;
+}
+function textArrayLiteral(values) {
+	return sql`ARRAY[${sql.join(values.map((value) => sql`${value}`), sql`, `)}]::text[]`;
+}
+function tagsContainAll(tags) {
+	return tags && tags.length > 0 ? sql`${memoriesTable.tags} @> ${textArrayLiteral(tags)}` : void 0;
+}
+function rawTagsFilter(tags) {
+	return tags && tags.length > 0 ? sql`AND tags @> ${textArrayLiteral(tags)}` : sql``;
+}
+function duplicateTagsFilter(tags) {
+	return tags && tags.length > 0 ? sql`AND a.tags @> ${textArrayLiteral(tags)} AND b.tags @> ${textArrayLiteral(tags)}` : sql``;
+}
+function memoryStatsCountFields(now) {
+	return {
+		memoryCount: count(),
+		activeMemoryCount: sql`
+			(count(*) FILTER (
+				WHERE ${memoriesTable.supersededBy} IS NULL
+					AND (${memoriesTable.expiresAt} IS NULL OR ${memoriesTable.expiresAt} > ${timestampParam(now)})
+			))::int
+		`.mapWith(Number),
+		expiredMemoryCount: sql`
+			(count(*) FILTER (
+				WHERE ${memoriesTable.expiresAt} IS NOT NULL
+					AND ${memoriesTable.expiresAt} <= ${timestampParam(now)}
+			))::int
+		`.mapWith(Number),
+		supersededMemoryCount: sql`(count(*) FILTER (WHERE ${memoriesTable.supersededBy} IS NOT NULL))::int`.mapWith(Number)
+	};
+}
+function emptyMemoryStatsCounts() {
+	return {
+		memoryCount: 0,
+		activeMemoryCount: 0,
+		expiredMemoryCount: 0,
+		supersededMemoryCount: 0
+	};
 }
 async function insertMemory(db, row) {
 	const inserted = (await db.insert(memoriesTable).values(row).returning())[0];
-	if (!inserted) throw new Error("Memory insert returned no rows.");
+	if (!inserted) throw new MnemocyteError("Memory insert returned no rows.", "DB");
 	return inserted;
 }
+async function insertMemories(db, rows) {
+	if (rows.length === 0) return [];
+	return db.insert(memoriesTable).values(rows).returning();
+}
 async function getMemoryById(db, entityId, memoryId) {
 	return (await db.select().from(memoriesTable).where(and(eq(memoriesTable.entityId, entityId), eq(memoriesTable.id, memoryId))).limit(1))[0] ?? null;
 }
-async function listMemories(db, filter) {
-	return db.select().from(memoriesTable).where(filterConditions(filter));
+async function getEntityMemoryStatsCounts(db, entityId, now) {
+	return (await db.select(memoryStatsCountFields(now)).from(memoriesTable).where(eq(memoriesTable.entityId, entityId)))[0] ?? emptyMemoryStatsCounts();
+}
+async function getGlobalMemoryStatsCounts(db, now) {
+	return (await db.select({
+		entityCount: countDistinct(memoriesTable.entityId),
+		...memoryStatsCountFields(now)
+	}).from(memoriesTable))[0] ?? {
+		entityCount: 0,
+		...emptyMemoryStatsCounts()
+	};
 }
 async function deleteMemory(db, entityId, memoryId) {
 	return (await db.delete(memoriesTable).where(and(eq(memoriesTable.entityId, entityId), eq(memoriesTable.id, memoryId))).returning({ id: memoriesTable.id })).length > 0;
@@ -1056,10 +1205,10 @@ async function deleteMemoriesForEntity(db, entityId) {
 	return (await db.delete(memoriesTable).where(eq(memoriesTable.entityId, entityId)).returning({ id: memoriesTable.id })).length;
 }
 function pruneConditions(filter) {
-	return and(filter.entityId !== void 0 ? eq(memoriesTable.entityId, filter.entityId) : void 0, filter.expired ? and(isNotNull(memoriesTable.expiresAt), sql`${memoriesTable.expiresAt} <= now()`) : void 0, filter.superseded ? isNotNull(memoriesTable.supersededBy) : void 0, filter.createdBefore ? lt(memoriesTable.createdAt, filter.createdBefore) : void 0, filter.notAccessedSince ? or(isNull(memoriesTable.lastAccessedAt), lt(memoriesTable.lastAccessedAt, filter.notAccessedSince)) : void 0, filter.types && filter.types.length > 0 ? inArray(memoriesTable.type, [...filter.types]) : void 0, filter.tags && filter.tags.length > 0 ? sql`${memoriesTable.tags} @> ${filter.tags}` : void 0, filter.maxImportanceLevels && filter.maxImportanceLevels.length > 0 ? inArray(memoriesTable.importance, [...filter.maxImportanceLevels]) : void 0);
+	return and(filter.entityId !== void 0 ? eq(memoriesTable.entityId, filter.entityId) : void 0, filter.expired ? and(isNotNull(memoriesTable.expiresAt), sql`${memoriesTable.expiresAt} <= now()`) : void 0, filter.superseded ? isNotNull(memoriesTable.supersededBy) : void 0, filter.createdBefore ? lt(memoriesTable.createdAt, filter.createdBefore) : void 0, filter.notAccessedSince ? or(isNull(memoriesTable.lastAccessedAt), lt(memoriesTable.lastAccessedAt, filter.notAccessedSince)) : void 0, filter.types && filter.types.length > 0 ? inArray(memoriesTable.type, [...filter.types]) : void 0, tagsContainAll(filter.tags), filter.maxImportanceLevels && filter.maxImportanceLevels.length > 0 ? inArray(memoriesTable.importance, [...filter.maxImportanceLevels]) : void 0);
 }
 async function countPruneMatches(db, filter) {
-	return (await db.select({ count: sql`count(*)::int` }).from(memoriesTable).where(pruneConditions(filter)))[0]?.count ?? 0;
+	return db.$count(memoriesTable, pruneConditions(filter));
 }
 async function pruneMemories(db, filter) {
 	return (await db.delete(memoriesTable).where(pruneConditions(filter)).returning({ id: memoriesTable.id })).length;
@@ -1117,7 +1266,7 @@ async function findDuplicatePairs(db, input) {
 			${input.includeSuperseded ? sql`` : sql`AND a.superseded_by IS NULL AND b.superseded_by IS NULL`}
 			${input.includeExpired ? sql`` : sql`AND (a.expires_at IS NULL OR a.expires_at > now()) AND (b.expires_at IS NULL OR b.expires_at > now())`}
 			${input.types && input.types.length > 0 ? sql`AND a.type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)}) AND b.type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)})` : sql``}
-			${input.tags && input.tags.length > 0 ? sql`AND a.tags @> ${input.tags} AND b.tags @> ${input.tags}` : sql``}
+			${duplicateTagsFilter(input.tags)}
 			AND 1 - (a.embedding <=> b.embedding) >= ${input.threshold}
 		ORDER BY "similarity" DESC
 		LIMIT ${input.limit}
@@ -1195,13 +1344,22 @@ async function setMemoryTags(db, params) {
 	}).where(and(eq(memoriesTable.entityId, params.entityId), eq(memoriesTable.id, params.memoryId)));
 }
 async function markMemoryAccessed(db, memoryIds) {
+	const now = /* @__PURE__ */ new Date();
 	if (memoryIds.length === 0) return;
 	await db.update(memoriesTable).set({
-		lastAccessedAt: /* @__PURE__ */ new Date(),
+		lastAccessedAt: now,
 		accessCount: sql`${memoriesTable.accessCount} + 1`,
-		updatedAt: /* @__PURE__ */ new Date()
+		updatedAt: now
 	}).where(inArray(memoriesTable.id, [...memoryIds]));
 }
+async function getMemoryEmbeddings(db, memoryIds) {
+	if (memoryIds.length === 0) return /* @__PURE__ */ new Map();
+	const rows = await db.select({
+		id: memoriesTable.id,
+		embedding: memoriesTable.embedding
+	}).from(memoriesTable).where(inArray(memoriesTable.id, [...memoryIds]));
+	return new Map(rows.flatMap((row) => row.embedding ? [[row.id, row.embedding]] : []));
+}
 async function vectorSearch(db, input) {
 	const embedding = vectorLiteral(input.embedding);
 	const minScore = input.minScore ?? 0;
@@ -1216,7 +1374,6 @@ async function vectorSearch(db, input) {
 			source,
 			metadata,
 			confidence,
-			embedding,
 			embedding_model AS "embeddingModel",
 			embedding_dimensions AS "embeddingDimensions",
 			superseded_by AS "supersededBy",
@@ -1234,9 +1391,9 @@ async function vectorSearch(db, input) {
 			${input.includeSuperseded ? sql`` : sql`AND superseded_by IS NULL`}
 			${input.includeExpired ? sql`` : sql`AND (expires_at IS NULL OR expires_at > now())`}
 			${input.types && input.types.length > 0 ? sql`AND type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)})` : sql``}
-			${input.tags && input.tags.length > 0 ? sql`AND tags @> ${input.tags}` : sql``}
-			${input.before ? sql`AND created_at < ${input.before}` : sql``}
-			${input.after ? sql`AND created_at > ${input.after}` : sql``}
+			${rawTagsFilter(input.tags)}
+			${input.before ? sql`AND created_at < ${timestampParam(input.before)}` : sql``}
+			${input.after ? sql`AND created_at > ${timestampParam(input.after)}` : sql``}
 			AND 1 - (embedding <=> ${embedding}::vector) >= ${minScore}
 		ORDER BY embedding <=> ${embedding}::vector
 		LIMIT ${input.limit}
@@ -1254,7 +1411,6 @@ async function lexicalSearch(db, input) {
 			source,
 			metadata,
 			confidence,
-			embedding,
 			embedding_model AS "embeddingModel",
 			embedding_dimensions AS "embeddingDimensions",
 			superseded_by AS "supersededBy",
@@ -1271,9 +1427,9 @@ async function lexicalSearch(db, input) {
 			${input.includeSuperseded ? sql`` : sql`AND superseded_by IS NULL`}
 			${input.includeExpired ? sql`` : sql`AND (expires_at IS NULL OR expires_at > now())`}
 			${input.types && input.types.length > 0 ? sql`AND type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)})` : sql``}
-			${input.tags && input.tags.length > 0 ? sql`AND tags @> ${input.tags}` : sql``}
-			${input.before ? sql`AND created_at < ${input.before}` : sql``}
-			${input.after ? sql`AND created_at > ${input.after}` : sql``}
+			${rawTagsFilter(input.tags)}
+			${input.before ? sql`AND created_at < ${timestampParam(input.before)}` : sql``}
+			${input.after ? sql`AND created_at > ${timestampParam(input.after)}` : sql``}
 			AND to_tsvector('english', content) @@ websearch_to_tsquery('english', ${input.query})
 		ORDER BY "lexicalScore" DESC
 		LIMIT ${input.limit}
@@ -1288,6 +1444,8 @@ async function hybridRecall(input) {
 	});
 	const candidateMultiplier = input.retrieval?.candidateMultiplier ?? 3;
 	const candidateLimit = Math.max(input.limit, input.limit * candidateMultiplier);
+	const scoreLexical = createLexicalScorer(input.input.query);
+	const scoringConfig = createScoringConfig(input.retrieval);
 	const [vectorRows, lexicalRows] = await Promise.all([vectorSearch(input.db, {
 		...input.input,
 		embedding: queryEmbedding,
@@ -1301,18 +1459,24 @@ async function hybridRecall(input) {
 	for (const row of vectorRows) merged.set(row.id, {
 		row,
 		vectorScore: row.vectorScore,
-		lexicalScore: 0
+		lexicalScore: scoreLexical(row.content)
 	});
+	const lexicalOnlyRows = lexicalRows.filter((row) => !merged.has(row.id));
+	const lexicalOnlyEmbeddings = await getMemoryEmbeddings(input.db, lexicalOnlyRows.map((row) => row.id));
 	for (const row of lexicalRows) {
 		const existing = merged.get(row.id);
 		if (existing) existing.lexicalScore = row.lexicalScore;
-		else merged.set(row.id, {
-			row,
-			vectorScore: 0,
-			lexicalScore: row.lexicalScore
-		});
+		else {
+			const embedding = lexicalOnlyEmbeddings.get(row.id);
+			const sim = embedding ? cosineSimilarity(embedding, queryEmbedding) : 0;
+			merged.set(row.id, {
+				row,
+				vectorScore: Math.max(0, sim),
+				lexicalScore: row.lexicalScore
+			});
+		}
 	}
-	const scored = Array.from(merged.values()).map((entry) => toScoredMemory(rowToMemory(entry.row), Math.max(0, entry.vectorScore), Math.max(0, entry.lexicalScore), input.input, input.retrieval)).filter((memory) => memory.score >= input.minScore).sort((a, b) => b.score - a.score).slice(0, input.limit);
+	const scored = Array.from(merged.values()).map((entry) => toScoredMemoryWithConfig(rowToMemory(entry.row), Math.max(0, entry.vectorScore), Math.max(0, entry.lexicalScore), input.input, scoringConfig)).filter((memory) => memory.score >= input.minScore).sort((a, b) => b.score - a.score).slice(0, input.limit);
 	await markMemoryAccessed(input.db, scored.map((memory) => memory.id));
 	return scored;
 }
@@ -1406,14 +1570,46 @@ function createPostgresClient(config, handle) {
 			count: 1
 		}));
 	}
-	return {
+	const client = {
 		remember,
 		async rememberMany(inputs) {
 			return observe(config, "postgres", "rememberMany", { count: inputs.length }, async () => {
 				assertOpen();
-				const result = [];
-				for (const input of inputs) result.push(await remember(input));
-				return result;
+				if (inputs.length === 0) return [];
+				for (const input of inputs) validateRememberInput(input);
+				const embeddings = await embedMany(config.embedder, inputs.map((i) => i.content), {
+					...inputs[0]?.signal === void 0 ? {} : { signal: inputs[0].signal },
+					...config.provider === void 0 ? {} : { resilience: config.provider }
+				});
+				const now = /* @__PURE__ */ new Date();
+				const rows = inputs.map((input, idx) => ({
+					id: createId(),
+					entityId: input.entityId,
+					content: input.content,
+					type: input.type ?? "fact",
+					importance: input.importance ?? "normal",
+					tags: normalizeTags(input.tags),
+					source: input.source ?? null,
+					metadata: input.metadata ?? {},
+					confidence: input.confidence ?? 1,
+					embedding: embeddings[idx],
+					embeddingModel: config.embedder.model,
+					embeddingDimensions: config.embedder.dimensions,
+					supersededBy: null,
+					supersededAt: null,
+					expiresAt: input.expiresAt ?? null,
+					lastAccessedAt: null,
+					accessCount: 0,
+					createdAt: now,
+					updatedAt: now
+				}));
+				const memories = (await insertMemories(handle.db, rows)).map(rowToMemory);
+				for (const memory of memories) recordAudit(memory.entityId, "memory.created", {
+					memoryId: memory.id,
+					type: memory.type,
+					importance: memory.importance
+				});
+				return memories;
 			}, (result) => ({ count: result.length }));
 		},
 		async recall(input) {
@@ -1443,7 +1639,7 @@ function createPostgresClient(config, handle) {
 					input,
 					recall: (contextInput) => {
 						const recallInput = contextInputToRecallInput(contextInput);
-						return this.recall(input.signal === void 0 ? recallInput : {
+						return client.recall(input.signal === void 0 ? recallInput : {
 							...recallInput,
 							signal: input.signal
 						});
@@ -1529,27 +1725,13 @@ function createPostgresClient(config, handle) {
 				assertOpen();
 				const now = /* @__PURE__ */ new Date();
 				if (input?.entityId) {
-					const selected = await listMemories(handle.db, {
-						entityId: input.entityId,
-						includeExpired: true,
-						includeSuperseded: true
-					});
+					const counts = await getEntityMemoryStatsCounts(handle.db, input.entityId, now);
 					return {
 						entityId: input.entityId,
-						memoryCount: selected.length,
-						activeMemoryCount: selected.filter((memory) => !isExpired(rowToMemory(memory), now) && memory.supersededBy === null).length,
-						expiredMemoryCount: selected.filter((memory) => isExpired(rowToMemory(memory), now)).length,
-						supersededMemoryCount: selected.filter((memory) => memory.supersededBy !== null).length
+						...counts
 					};
 				}
-				const allMemories = await handle.db.select().from(memoriesTable);
-				return {
-					entityCount: new Set(allMemories.map((memory) => memory.entityId)).size,
-					memoryCount: allMemories.length,
-					activeMemoryCount: allMemories.filter((memory) => !isExpired(rowToMemory(memory), now) && memory.supersededBy === null).length,
-					expiredMemoryCount: allMemories.filter((memory) => isExpired(rowToMemory(memory), now)).length,
-					supersededMemoryCount: allMemories.filter((memory) => memory.supersededBy !== null).length
-				};
+				return await getGlobalMemoryStatsCounts(handle.db, now);
 			});
 		},
 		experimental: createExperimental(),
@@ -1560,6 +1742,7 @@ function createPostgresClient(config, handle) {
 			});
 		}
 	};
+	return client;
 	function createExperimental() {
 		return { async consolidate(input) {
 			return observe(config, "postgres", "consolidate", {
@@ -1581,27 +1764,39 @@ function createPostgresClient(config, handle) {
 					supersededIds: []
 				};
 				const now = /* @__PURE__ */ new Date();
-				const updated = await markMemoriesSuperseded(handle.db, {
-					survivorId: survivor.id,
-					entityId: input.entityId,
-					ids: losers.map((loser) => loser.id),
-					now
-				});
-				const newSupersededIds = updated.map((row) => row.id);
-				for (const id of newSupersededIds) await recordAudit(input.entityId, "memory.superseded", {
-					memoryId: id,
-					supersededBy: survivor.id
-				});
-				if (input.mergeTags !== false && updated.length > 0) {
-					const mergedTags = new Set(survivor.tags);
-					for (const row of updated) for (const tag of row.tags) mergedTags.add(tag);
-					if (mergedTags.size !== survivor.tags.length) await setMemoryTags(handle.db, {
+				const { newSupersededIds } = await handle.db.transaction(async (tx) => {
+					const updated = await markMemoriesSuperseded(tx, {
+						survivorId: survivor.id,
 						entityId: input.entityId,
-						memoryId: survivor.id,
-						tags: [...mergedTags],
+						ids: losers.map((loser) => loser.id),
 						now
 					});
-				}
+					const newSupersededIds = updated.map((row) => row.id);
+					if (config.audit?.enabled === true) for (const id of newSupersededIds) await insertEvent(tx, {
+						id: createEventId(),
+						entityId: input.entityId,
+						description: "memory.superseded",
+						metadata: {
+							memoryId: id,
+							supersededBy: survivor.id
+						},
+						timestamp: now
+					});
+					if (input.mergeTags !== false && updated.length > 0) {
+						const mergedTags = new Set(survivor.tags);
+						for (const row of updated) for (const tag of row.tags) mergedTags.add(tag);
+						if (mergedTags.size !== survivor.tags.length) await setMemoryTags(tx, {
+							entityId: input.entityId,
+							memoryId: survivor.id,
+							tags: [...mergedTags],
+							now
+						});
+					}
+					return {
+						updated,
+						newSupersededIds
+					};
+				});
 				return {
 					survivorId: survivor.id,
 					supersededCount: newSupersededIds.length,