@oh-my-pi/pi-mnemopi 18.18.3 → 18.18.4

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [18.18.4] - 2026-11-09
+
+### Fixed
+
+- Fixed late background embedding writes overwriting newer vectors for updated memories or recreating vectors for deleted memories ([#18503](https://github.com/can1357/oh-my-pi/pull/18503) by [@eggpeat](https://github.com/eggpeat))
+- Fixed a second `Mnemopi` instance configured for a different local embedding model silently reusing the first instance's encoder while stamping its vectors with the configured model: local encoders are now cached per model, and a failed load evicts only that model's entry ([#18562](https://github.com/can1357/oh-my-pi/pull/18562) by [@eggpeat](https://github.com/eggpeat))
+
 ## [18.18.2] - 2026-11-08
 
 ### Fixed

package/dist/types/core/beam/helpers.d.ts

@@ -53,6 +53,24 @@ export interface EmbedItem {
     readonly memoryId: string;
     readonly content: string;
 }
+/** One derived vector waiting to be written, keyed to the memory and the exact text embedded. */
+export interface StagedEmbedding extends EmbedItem {
+    readonly json: string;
+}
+/**
+ * Upsert each staged vector only if its memory is still live (not superseded) and its
+ * effective embedding text -- `COALESCE(embed_text, content)` for working memories,
+ * `content` for episodic ones -- still equals the text that was embedded. Returns the
+ * number of rows actually written, which is what gates callers' cache invalidation.
+ * `memory_embeddings` rows are only ever written here, so this is the one place that
+ * rejects the two stale writes of a slow `embed()` call: a late vector for a memory
+ * whose text changed after an update, and a late vector for a deleted memory.
+ *
+ * Relies on every `scheduleEmbedding` caller passing exactly the stored effective text
+ * (`remember`, `rememberBatch`, `updateWorking` -- which nulls `embed_text` -- and
+ * `consolidateToEpisodic`); a mismatched text is silently dropped, not re-embedded.
+ */
+export declare function insertLiveEmbeddings(db: Database, rows: readonly StagedEmbedding[], model: string): number;
 /**
  * Schedule background embedding generation for one or more freshly stored memories.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-mnemopi",
-	"version": "18.18.3",
+	"version": "18.18.4",
 	"description": "Local SQLite memory engine for omp agents",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -42,10 +42,10 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.18.3",
-		"@oh-my-pi/pi-catalog": "18.18.3",
-		"@oh-my-pi/pi-natives": "18.18.3",
-		"@oh-my-pi/pi-utils": "18.18.3"
+		"@oh-my-pi/pi-ai": "18.18.4",
+		"@oh-my-pi/pi-catalog": "18.18.4",
+		"@oh-my-pi/pi-natives": "18.18.4",
+		"@oh-my-pi/pi-utils": "18.18.4"
 	},
 	"peerDependencies": {
 		"fastembed": "3.0.0",

package/src/core/beam/helpers.ts

@@ -723,6 +723,54 @@ export interface EmbedItem {
 	readonly content: string;
 }
 
+/** One derived vector waiting to be written, keyed to the memory and the exact text embedded. */
+export interface StagedEmbedding extends EmbedItem {
+	readonly json: string;
+}
+
+const INSERT_LIVE_EMBEDDING_SQL = `
+	INSERT OR REPLACE INTO memory_embeddings(memory_id, embedding_json, model)
+	SELECT ?, ?, ?
+	WHERE EXISTS (
+		SELECT 1 FROM working_memory
+		WHERE id = ? AND superseded_by IS NULL AND COALESCE(embed_text, content) = ?
+	) OR EXISTS (
+		SELECT 1 FROM episodic_memory
+		WHERE id = ? AND superseded_by IS NULL AND content = ?
+	)
+`;
+
+/**
+ * Upsert each staged vector only if its memory is still live (not superseded) and its
+ * effective embedding text -- `COALESCE(embed_text, content)` for working memories,
+ * `content` for episodic ones -- still equals the text that was embedded. Returns the
+ * number of rows actually written, which is what gates callers' cache invalidation.
+ * `memory_embeddings` rows are only ever written here, so this is the one place that
+ * rejects the two stale writes of a slow `embed()` call: a late vector for a memory
+ * whose text changed after an update, and a late vector for a deleted memory.
+ *
+ * Relies on every `scheduleEmbedding` caller passing exactly the stored effective text
+ * (`remember`, `rememberBatch`, `updateWorking` -- which nulls `embed_text` -- and
+ * `consolidateToEpisodic`); a mismatched text is silently dropped, not re-embedded.
+ */
+export function insertLiveEmbeddings(db: Database, rows: readonly StagedEmbedding[], model: string): number {
+	using insertEmbedding = db.prepare(INSERT_LIVE_EMBEDDING_SQL);
+	let committed = 0;
+	for (const row of rows) {
+		const result = insertEmbedding.run(
+			row.memoryId,
+			row.json,
+			model,
+			row.memoryId,
+			row.content,
+			row.memoryId,
+			row.content,
+		);
+		committed += result.changes;
+	}
+	return committed;
+}
+
 async function runEmbedding(beam: BeamMemoryState, items: readonly EmbedItem[]): Promise<void> {
 	try {
 		const matrix = await embed(items.map(item => item.content));
@@ -731,27 +779,29 @@ async function runEmbedding(beam: BeamMemoryState, items: readonly EmbedItem[]):
 		// stall is attributable. The embedding itself is awaited above, outside the label.
 		withLoopPhase("mnemopi.embed-persist", () => {
 			const model = currentEmbeddingModel();
-			using insertEmbedding = beam.db.prepare(
-				"INSERT OR REPLACE INTO memory_embeddings(memory_id, embedding_json, model) VALUES (?, ?, ?)",
+			const staged: StagedEmbedding[] = [];
+			for (let i = 0; i < items.length; i += 1) {
+				const vector = matrix[i];
+				const item = items[i];
+				if (vector === undefined || item === undefined) continue;
+				staged.push({
+					memoryId: item.memoryId,
+					content: item.content,
+					json: JSON.stringify(Array.from(vector)),
+				});
+			}
+			const insertMany = beam.db.transaction((rows: readonly StagedEmbedding[]) =>
+				insertLiveEmbeddings(beam.db, rows, model),
 			);
-			let committed = 0;
-			const insertMany = beam.db.transaction((rows: readonly EmbedItem[]) => {
-				for (let i = 0; i < rows.length; i += 1) {
-					const vector = matrix[i];
-					const item = rows[i];
-					if (vector === undefined || item === undefined) continue;
-					insertEmbedding.run(item.memoryId, JSON.stringify(Array.from(vector)), model);
-					committed += 1;
-				}
-			});
-			insertMany(items);
+			const committed = insertMany(staged);
 			// A recall taken while these vectors were still generating cached an FTS-only ranking, and
 			// committing vectors changes what recall returns -- so that cache must be dropped, or the
 			// pre-embedding order keeps being served for the whole cache TTL. Gated on `committed`: a
-			// batch whose provider returned a short or empty matrix inserts nothing, changes no ranking,
-			// and invalidating there would only discard a still-valid cache. Only the query cache is
-			// affected; the polyphonic subject dictionary is built from facts/gists, which an embedding
-			// batch never touches.
+			// batch whose provider returned a short or empty matrix inserts nothing, and a row whose
+			// memory was updated or deleted while its vector was in flight is discarded instead of
+			// written; neither changes a ranking, and invalidating there would only discard a
+			// still-valid cache. Only the query cache is affected; the polyphonic subject dictionary
+			// is built from facts/gists, which an embedding batch never touches.
 			if (committed > 0) beam.caches.queryCache?.invalidate();
 		});
 	} catch (error) {

package/src/core/beam/store.ts

@@ -8,7 +8,14 @@ import { EpisodicGraph } from "../episodic-graph";
 import { countExtractedFactCategories, extractFactCategoriesSafe } from "../extraction";
 import { getMnemopiRuntimeOptions, withMnemopiRuntimeOptions } from "../runtime-options";
 import { storeExtractedFactCategories } from "./consolidate";
-import { type EmbedItem, scheduleEmbedding, vecAvailable, vecInsert } from "./helpers";
+import {
+	type EmbedItem,
+	insertLiveEmbeddings,
+	type StagedEmbedding,
+	scheduleEmbedding,
+	vecAvailable,
+	vecInsert,
+} from "./helpers";
 import type {
 	BeamEvent,
 	BeamMemoryState,
@@ -407,7 +414,7 @@ export function reconcileEmbeddingModel(beam: BeamMemoryState): void {
 				// Embed the whole corpus before touching anything stored. embed() handles the provider's
 				// per-request cap; a rejected chunk abandons the rebuild and leaves the stored vectors alone.
 				const toEmbed = live.filter(item => item.content.trim() !== "");
-				const staged: { memoryId: string; content: string; json: string }[] = [];
+				const staged: StagedEmbedding[] = [];
 				for (let offset = 0; offset < toEmbed.length; offset += EMBED_REBUILD_BATCH) {
 					const chunk = toEmbed.slice(offset, offset + EMBED_REBUILD_BATCH);
 					const vectors = await embed(chunk.map(item => item.content));
@@ -443,28 +450,7 @@ export function reconcileEmbeddingModel(beam: BeamMemoryState): void {
 							// sqlite-vec cleanup is best-effort; rebuild correctness takes precedence.
 						}
 					}
-					using insertEmbedding = beam.db.prepare(`
-						INSERT OR REPLACE INTO memory_embeddings(memory_id, embedding_json, model)
-						SELECT ?, ?, ?
-						WHERE EXISTS (
-							SELECT 1 FROM working_memory
-							WHERE id = ? AND superseded_by IS NULL AND COALESCE(embed_text, content) = ?
-						) OR EXISTS (
-							SELECT 1 FROM episodic_memory
-							WHERE id = ? AND superseded_by IS NULL AND content = ?
-						)
-					`);
-					for (const row of staged) {
-						insertEmbedding.run(
-							row.memoryId,
-							row.json,
-							active,
-							row.memoryId,
-							row.content,
-							row.memoryId,
-							row.content,
-						);
-					}
+					insertLiveEmbeddings(beam.db, staged, active);
 				});
 				beam.caches.queryCache?.invalidate();
 

package/src/core/embeddings.ts

@@ -52,7 +52,11 @@ export type LocalModelInitializer = (options: LocalModelInitOptions) => Promise<
 const QUERY_CACHE_MAX = 512;
 
 let providerOverride: EmbeddingProvider | null = null;
-let localModelPromise: Promise<LocalEmbeddingModel> | null = null;
+// Local encoders are cached per resolved fastembed model id: two Mnemopi instances
+// in one process configured with different local models must each load their own
+// encoder instead of reusing whichever model happened to initialize first. A failed
+// init evicts only that model's entry so other models' encoders stay warm.
+const localModelPromises = new Map<string, Promise<LocalEmbeddingModel>>();
 let localModelInitializer: LocalModelInitializer = defaultLocalModelInitializer;
 let apiCallCount = 0;
 const queryCache = new LRUCache<string, Vector>({ max: QUERY_CACHE_MAX });
@@ -330,17 +334,20 @@ export function fastembedModelName(modelName: string): StandardEmbeddingModel |
 }
 
 async function getLocalModel(): Promise<LocalEmbeddingModel | null> {
-	if (isApiModel(defaultModel()) || embeddingsDisabled() || inTestRuntime()) {
+	const configuredModel = defaultModel();
+	if (isApiModel(configuredModel) || embeddingsDisabled() || inTestRuntime()) {
 		return null;
 	}
-	if (localModelPromise !== null) {
-		return localModelPromise;
-	}
 
-	const modelName = fastembedModelName(defaultModel());
+	const modelName = fastembedModelName(configuredModel);
 	if (modelName === null) {
 		return null;
 	}
+	const cached = localModelPromises.get(modelName);
+	if (cached !== undefined) {
+		return cached;
+	}
+
 	const cacheDir = getFastembedCacheDir();
 	mkdirSync(cacheDir, { recursive: true });
 	const loading = localModelInitializer({
@@ -348,7 +355,7 @@ async function getLocalModel(): Promise<LocalEmbeddingModel | null> {
 		cacheDir,
 		showDownloadProgress: false,
 	});
-	localModelPromise = loading;
+	localModelPromises.set(modelName, loading);
 	try {
 		return await loading;
 	} catch (error) {
@@ -356,7 +363,7 @@ async function getLocalModel(): Promise<LocalEmbeddingModel | null> {
 			model: modelName,
 			error: String(error),
 		});
-		if (localModelPromise === loading) localModelPromise = null;
+		if (localModelPromises.get(modelName) === loading) localModelPromises.delete(modelName);
 		return null;
 	}
 }
@@ -491,7 +498,7 @@ export const setEmbeddingProvider = setEmbeddingProviderForTests;
 
 export function setLocalModelInitializerForTests(initializer: LocalModelInitializer | null | undefined): void {
 	localModelInitializer = initializer ?? defaultLocalModelInitializer;
-	localModelPromise = null;
+	localModelPromises.clear();
 	queryCache.clear();
 }
 
@@ -507,7 +514,7 @@ export const setLocalModelInitializer = setLocalModelInitializerForTests;
 
 export function resetEmbeddingProviderForTests(): void {
 	providerOverride = null;
-	localModelPromise = null;
+	localModelPromises.clear();
 	localModelInitializer = defaultLocalModelInitializer;
 	apiCallCount = 0;
 	queryCache.clear();