mnemocyte 0.1.2 → 0.1.4

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/client.ts","../src/errors.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/client.ts","../src/errors.ts"],"mappings":";;;;;AAqCA;;;;;;;;AAAyE;;;;ACzBzE;;;;AAA8B;AA6B9B;;;;;;;;iBDJgB,eAAA,CAAgB,MAAA,EAAQ,eAAA,GAAkB,eAAe;;;;;;AAAzE;;;;;;;;AAAyE;KCzB7D,kBAAA;;;AAAZ;;;;AAA8B;AA6B9B;;;;;;;;;;;;cAAa,cAAA,SAAuB,KAAA;EAWvB;EAAA,SATH,IAAA,EAAM,kBAAA;EASc;EAAA,SAPX,KAAA;EAOoD;AAAA;AAiBvE;;;cAjBa,OAAA,UAAiB,IAAA,EAAM,kBAAA,EAAoB,KAAA;AAAA;;;;AAiBiB;;;;;;iBAAzD,gBAAA,CAAiB,KAAA,YAAiB,KAAA,IAAS,cAAc"}

package/dist/index.mjs

@@ -1,6 +1,7 @@
+import { n as isMnemocyteError, t as MnemocyteError } from "./errors-BG3-mNur.mjs";
 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 +55,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 +69,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 }),
@@ -78,56 +94,6 @@ function createDatabase(databaseUrl) {
 	};
 }
 //#endregion
-//#region src/errors.ts
-/**
-* Error type thrown by every public Mnemocyte API.
-*
-* Use the {@link MnemocyteError.code} property — not the message — to branch
-* on failure modes, or call {@link isMnemocyteError} as a type guard when
-* working with `unknown` errors.
-*
-* @example
-* ```ts
-* try {
-*   await client.recall({ entityId: "u1", query: "hi" });
-* } catch (err) {
-*   if (isMnemocyteError(err) && err.code === "DB") {
-*     // handle database failure
-*   }
-*   throw err;
-* }
-* ```
-*/
-var MnemocyteError = class extends Error {
-	/** Stable, machine-readable failure code. See {@link MnemocyteErrorCode}. */
-	code;
-	/** Underlying cause, if any (e.g. an original driver or embedder error). */
-	cause;
-	/**
-	* @param message - Human-readable error message.
-	* @param code - Stable failure code; see {@link MnemocyteErrorCode}.
-	* @param cause - Optional underlying cause (driver error, network error, etc.).
-	*/
-	constructor(message, code, cause) {
-		super(message);
-		this.name = "MnemocyteError";
-		this.code = code;
-		this.cause = cause;
-	}
-};
-/**
-* Type guard for {@link MnemocyteError}.
-*
-* Prefer this over `instanceof` when working across module boundaries or
-* bundlers where multiple copies of the class may exist.
-*
-* @param error - Value to test (typically a caught `unknown`).
-* @returns `true` if `error` is a {@link MnemocyteError}.
-*/
-function isMnemocyteError(error) {
-	return error instanceof MnemocyteError;
-}
-//#endregion
 //#region src/context/formatter.ts
 function escapeXml(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
@@ -313,6 +279,13 @@ function defaultShouldRetry(error) {
 		if (error.code === "VALIDATION" || error.code === "CONFIG" || error.code === "ABORTED") return false;
 		return true;
 	}
+	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number" && [
+		429,
+		500,
+		502,
+		503,
+		504
+	].includes(error.status)) return true;
 	if (error instanceof Error) {
 		const message = error.message.toLowerCase();
 		if (message.includes("econn") || message.includes("etimedout") || message.includes("network") || message.includes("timeout") || message.includes("temporarily") || message.includes("rate limit") || message.includes("503") || message.includes("502") || message.includes("504") || message.includes("500")) return true;
@@ -489,6 +462,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,
@@ -503,12 +482,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 = {}) {
@@ -681,12 +660,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));
@@ -707,6 +692,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);
@@ -716,11 +708,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 {
@@ -817,7 +809,7 @@ function createInMemoryClient(config) {
 			count: 1
 		}));
 	}
-	return {
+	const client = {
 		remember,
 		async rememberMany(inputs) {
 			return observe(config, "in-memory", "rememberMany", { count: inputs.length }, async () => {
@@ -877,7 +869,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) {
@@ -896,7 +890,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
 						});
@@ -1030,6 +1024,7 @@ function createInMemoryClient(config) {
 			});
 		}
 	};
+	return client;
 	function createExperimental() {
 		return { async consolidate(input) {
 			return observe(config, "in-memory", "consolidate", {
@@ -1081,7 +1076,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) {
@@ -1096,12 +1091,50 @@ 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) {
@@ -1111,8 +1144,17 @@ async function insertMemories(db, rows) {
 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;
@@ -1121,10 +1163,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;
@@ -1182,7 +1224,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}
@@ -1260,13 +1302,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;
@@ -1281,7 +1332,6 @@ async function vectorSearch(db, input) {
 			source,
 			metadata,
 			confidence,
-			embedding,
 			embedding_model AS "embeddingModel",
 			embedding_dimensions AS "embeddingDimensions",
 			superseded_by AS "supersededBy",
@@ -1299,9 +1349,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}
@@ -1319,7 +1369,6 @@ async function lexicalSearch(db, input) {
 			source,
 			metadata,
 			confidence,
-			embedding,
 			embedding_model AS "embeddingModel",
 			embedding_dimensions AS "embeddingDimensions",
 			superseded_by AS "supersededBy",
@@ -1336,9 +1385,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}
@@ -1353,6 +1402,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,
@@ -1366,13 +1417,15 @@ async function hybridRecall(input) {
 	for (const row of vectorRows) merged.set(row.id, {
 		row,
 		vectorScore: row.vectorScore,
-		lexicalScore: lexicalScore(row.content, input.input.query)
+		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 {
-			const embedding = row.embedding;
+			const embedding = lexicalOnlyEmbeddings.get(row.id);
 			const sim = embedding ? cosineSimilarity(embedding, queryEmbedding) : 0;
 			merged.set(row.id, {
 				row,
@@ -1381,7 +1434,7 @@ async function hybridRecall(input) {
 			});
 		}
 	}
-	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;
 }
@@ -1475,7 +1528,7 @@ function createPostgresClient(config, handle) {
 			count: 1
 		}));
 	}
-	return {
+	const client = {
 		remember,
 		async rememberMany(inputs) {
 			return observe(config, "postgres", "rememberMany", { count: inputs.length }, async () => {
@@ -1544,7 +1597,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
 						});
@@ -1630,27 +1683,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(),
@@ -1661,6 +1700,7 @@ function createPostgresClient(config, handle) {
 			});
 		}
 	};
+	return client;
 	function createExperimental() {
 		return { async consolidate(input) {
 			return observe(config, "postgres", "consolidate", {
@@ -1690,7 +1730,7 @@ function createPostgresClient(config, handle) {
 						now
 					});
 					const newSupersededIds = updated.map((row) => row.id);
-					for (const id of newSupersededIds) await insertEvent(tx, {
+					if (config.audit?.enabled === true) for (const id of newSupersededIds) await insertEvent(tx, {
 						id: createEventId(),
 						entityId: input.entityId,
 						description: "memory.superseded",