@oh-my-pi/pi-mnemopi 17.0.0 → 17.0.2

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [17.0.1] - 2026-07-16
+
+### Fixed
+
+- Fixed working-memory TTL trim silently deleting restored or imported durable rows: rows keeping `consolidated_at = NULL` with an old `timestamp` are no longer trimmed when flagged `IMPORTED`, `importFromDict` stamps imported rows as consolidated, and every working-memory delete path (trim, `forgetWorking`, force-import overwrite) now cascades linked annotations, embeddings, facts, memoria projections, gists, and graph edges instead of leaving orphans. ([#4819](https://github.com/can1357/oh-my-pi/issues/4819))
+- Fixed Mnemopi local embeddings on Windows loading an unrelated `onnxruntime.dll` from the inherited system path instead of fastembed's cached ORT runtime. ([#4849](https://github.com/can1357/oh-my-pi/issues/4849))
+
 ## [16.3.9] - 2026-07-06
 
 ### Fixed

package/dist/types/core/fastembed-runtime.d.ts

@@ -10,5 +10,32 @@ export interface FastembedRuntimeInstallPlan {
 }
 /** Build the deterministic fastembed runtime install plan used by local embeddings. */
 export declare function fastembedRuntimeInstallPlan(): FastembedRuntimeInstallPlan;
+/** Inputs for selecting the Windows DLL directory paired with a fastembed installation. */
+export interface WindowsFastembedRuntimeOptions {
+    /** Resolved fastembed package entry whose dependency graph owns the ORT binding. */
+    fastembedEntry: string;
+    /** Directory containing fastembed's manifest and nested dependency graph. */
+    fastembedPackageDir: string;
+    /** Native architecture to select; defaults to the current process architecture. */
+    arch?: string;
+    /** Environment receiving the DLL search path; defaults to the subprocess environment. */
+    env?: NodeJS.ProcessEnv;
+}
+/** The ORT module and DLL directory selected from fastembed's own dependency graph. */
+export interface WindowsFastembedRuntime {
+    /** Resolved entry for fastembed's own ONNX Runtime dependency. */
+    ortEntry: string;
+    /** Package directory containing the selected ORT manifest and native assets. */
+    ortPackageDir: string;
+    /** Directory prepended to `PATH` so Windows finds the paired native DLL. */
+    dllDir: string;
+}
+/**
+ * Prepend the ORT DLL directory paired with fastembed before Bun loads its
+ * native binding. Compiled Windows binaries extract `.node` files to a
+ * temporary directory, so the default DLL search can otherwise select an
+ * unrelated `onnxruntime.dll` from the inherited system path.
+ */
+export declare function prepareWindowsFastembedRuntime({ fastembedEntry, fastembedPackageDir, arch, env, }: WindowsFastembedRuntimeOptions): Promise<WindowsFastembedRuntime>;
 export declare function loadFastembed(): Promise<FastembedModule>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-mnemopi",
-	"version": "17.0.0",
+	"version": "17.0.2",
 	"description": "Local SQLite memory engine for Oh My Pi agents",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -39,9 +39,9 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "17.0.0",
-		"@oh-my-pi/pi-catalog": "17.0.0",
-		"@oh-my-pi/pi-utils": "17.0.0",
+		"@oh-my-pi/pi-ai": "17.0.2",
+		"@oh-my-pi/pi-catalog": "17.0.2",
+		"@oh-my-pi/pi-utils": "17.0.2",
 		"lru-cache": "11.5.2"
 	},
 	"peerDependencies": {

package/src/core/beam/store.ts

@@ -163,27 +163,106 @@ function findDuplicate(beam: BeamMemoryState, content: string): string | null {
 	return row?.id ?? null;
 }
 
+function tableExists(db: BeamMemoryState["db"], table: string): boolean {
+	return (
+		db
+			.prepare("SELECT 1 FROM sqlite_master WHERE type IN ('table','virtual table') AND name = ? LIMIT 1")
+			.get(table) !== null
+	);
+}
+
+/** Tables whose rows point back to a `working_memory` id via `source_memory_id`. */
+const MEMORIA_SOURCE_TABLES = [
+	"memoria_facts",
+	"memoria_instructions",
+	"memoria_kg",
+	"memoria_preferences",
+	"memoria_timelines",
+] as const;
+
+/**
+ * Remove every artifact linked to the given `working_memory` ids so no deletion
+ * path leaves orphans behind. Covers annotations, embeddings, extracted facts
+ * (`facts.source_msg_id`), memoria projections (`*.source_memory_id`), episodic
+ * gists, and the graph edges tied to those memory / gist / fact node ids.
+ *
+ * Idempotent and schema-tolerant: `gists` / `graph_edges` only exist once an
+ * `EpisodicGraph` has initialised, so they are guarded. Callers own the
+ * transaction and the base `working_memory` delete.
+ */
+function purgeWorkingMemoryArtifacts(db: BeamMemoryState["db"], ids: readonly string[]): void {
+	if (ids.length === 0) return;
+	const placeholders = ids.map(() => "?").join(", ");
+
+	const graphRefs = new Set<string>(ids);
+	for (const id of ids) graphRefs.add(`gist_${id}`);
+	if (tableExists(db, "facts")) {
+		const factRows = db.prepare(`SELECT fact_id FROM facts WHERE source_msg_id IN (${placeholders})`).all(...ids) as {
+			fact_id: string;
+		}[];
+		for (const row of factRows) graphRefs.add(row.fact_id);
+		db.prepare(`DELETE FROM facts WHERE source_msg_id IN (${placeholders})`).run(...ids);
+	}
+
+	db.prepare(`DELETE FROM annotations WHERE memory_id IN (${placeholders})`).run(...ids);
+	db.prepare(`DELETE FROM memory_embeddings WHERE memory_id IN (${placeholders})`).run(...ids);
+	for (const table of MEMORIA_SOURCE_TABLES) {
+		db.prepare(`DELETE FROM ${table} WHERE source_memory_id IN (${placeholders})`).run(...ids);
+	}
+
+	if (tableExists(db, "gists")) {
+		db.prepare(`DELETE FROM gists WHERE memory_id IN (${placeholders})`).run(...ids);
+	}
+	if (tableExists(db, "graph_edges")) {
+		const refs = [...graphRefs];
+		const refPlaceholders = refs.map(() => "?").join(", ");
+		db.prepare(`DELETE FROM graph_edges WHERE source IN (${refPlaceholders}) OR target IN (${refPlaceholders})`).run(
+			...refs,
+			...refs,
+		);
+	}
+}
+
+/**
+ * TTL / overflow trim for transient working memory. Only genuine scratch is
+ * eligible: `consolidated_at IS NULL` no longer suffices on its own, since
+ * restored or imported durable rows legitimately carry a NULL consolidation
+ * marker with an old event timestamp (issue #4819). Rows flagged `IMPORTED`
+ * are treated as durable and never trimmed, and trimmed rows cascade all linked
+ * artifacts via `purgeWorkingMemoryArtifacts`.
+ */
 function trimWorkingMemory(beam: BeamMemoryState): void {
 	const limit = beam.config.workingMemoryLimit;
 	if (!Number.isFinite(limit) || limit <= 0) return;
 	const ttlHours = beam.config.workingMemoryTtlHours;
 	const cutoff = toUtcIso(new Date(Date.now() - ttlHours * 3_600_000));
-	beam.db
-		.prepare(`
-			DELETE FROM working_memory
-			WHERE session_id = ?
-			  AND consolidated_at IS NULL
-			  AND (
-				timestamp < ? OR
-				id NOT IN (
+	transaction(beam.db, () => {
+		const ids = (
+			beam.db
+				.prepare(`
 					SELECT id FROM working_memory
-					WHERE session_id = ? AND consolidated_at IS NULL
-					ORDER BY timestamp DESC
-					LIMIT ?
-				)
-			  )
-		`)
-		.run(beam.sessionId, cutoff, beam.sessionId, limit);
+					WHERE session_id = ?
+					  AND consolidated_at IS NULL
+					  AND trust_tier IS NOT 'IMPORTED'
+					  AND (
+						timestamp < ? OR
+						id NOT IN (
+							SELECT id FROM working_memory
+							WHERE session_id = ? AND consolidated_at IS NULL AND trust_tier IS NOT 'IMPORTED'
+							ORDER BY timestamp DESC
+							LIMIT ?
+						)
+					  )
+				`)
+				.all(beam.sessionId, cutoff, beam.sessionId, limit) as { id: string }[]
+		).map(row => row.id);
+		if (ids.length === 0) return;
+		const placeholders = ids.map(() => "?").join(", ");
+		beam.db
+			.prepare(`DELETE FROM working_memory WHERE id IN (${placeholders}) AND session_id = ?`)
+			.run(...ids, beam.sessionId);
+		purgeWorkingMemoryArtifacts(beam.db, ids);
+	});
 }
 
 function addTemporalAnnotations(beam: BeamMemoryState, memoryId: string, timestamp: string, source: string): void {
@@ -715,7 +794,7 @@ export function forgetWorking(beam: BeamMemoryState, memoryId: string): boolean
 			.run(memoryId, beam.sessionId);
 		deleted = result.changes;
 		if (deleted > 0) {
-			beam.db.prepare("DELETE FROM annotations WHERE memory_id = ?").run(memoryId);
+			purgeWorkingMemoryArtifacts(beam.db, [memoryId]);
 		}
 	});
 	if (deleted > 0) invalidateCaches(beam);
@@ -811,6 +890,10 @@ export function importFromDict(beam: BeamMemoryState, data: Record<string, unkno
 		consolidation_log: { inserted: 0 },
 	} satisfies ImportStats;
 	const db: Database = beam.db;
+	// Imported working-memory rows are durable, not scratch: stamp any that
+	// arrive unconsolidated so the TTL trim treats them as consolidated and can
+	// never silently discard a restored bank (issue #4819).
+	const importedAt = toUtcIso();
 	const oldToNewRowid = new Map<number, number>();
 
 	transaction(db, () => {
@@ -825,6 +908,7 @@ export function importFromDict(beam: BeamMemoryState, data: Record<string, unkno
 			}
 			if (exists) {
 				db.prepare("DELETE FROM working_memory WHERE id = ?").run(id);
+				purgeWorkingMemoryArtifacts(db, [id]);
 				stats.working_memory.overwritten++;
 			} else {
 				stats.working_memory.inserted++;
@@ -851,7 +935,7 @@ export function importFromDict(beam: BeamMemoryState, data: Record<string, unkno
 				sqlBinding(item.last_recalled, null),
 				sqlBinding(item.created_at, null),
 				clampVeracity(item.veracity),
-				sqlBinding(item.consolidated_at, null),
+				item.consolidated_at == null ? importedAt : sqlBinding(item.consolidated_at, importedAt),
 				sqlBinding(item.memory_type, "unknown"),
 				sqlBinding(item.embed_text, null),
 				sqlBinding(item.author_id, null),

package/src/core/fastembed-runtime.ts

@@ -48,6 +48,67 @@ export function fastembedRuntimeInstallPlan(): FastembedRuntimeInstallPlan {
 }
 let fastembedLoad: Promise<FastembedModule> | null = null;
 
+/** Inputs for selecting the Windows DLL directory paired with a fastembed installation. */
+export interface WindowsFastembedRuntimeOptions {
+	/** Resolved fastembed package entry whose dependency graph owns the ORT binding. */
+	fastembedEntry: string;
+	/** Directory containing fastembed's manifest and nested dependency graph. */
+	fastembedPackageDir: string;
+	/** Native architecture to select; defaults to the current process architecture. */
+	arch?: string;
+	/** Environment receiving the DLL search path; defaults to the subprocess environment. */
+	env?: NodeJS.ProcessEnv;
+}
+
+/** The ORT module and DLL directory selected from fastembed's own dependency graph. */
+export interface WindowsFastembedRuntime {
+	/** Resolved entry for fastembed's own ONNX Runtime dependency. */
+	ortEntry: string;
+	/** Package directory containing the selected ORT manifest and native assets. */
+	ortPackageDir: string;
+	/** Directory prepended to `PATH` so Windows finds the paired native DLL. */
+	dllDir: string;
+}
+
+/**
+ * Prepend the ORT DLL directory paired with fastembed before Bun loads its
+ * native binding. Compiled Windows binaries extract `.node` files to a
+ * temporary directory, so the default DLL search can otherwise select an
+ * unrelated `onnxruntime.dll` from the inherited system path.
+ */
+export async function prepareWindowsFastembedRuntime({
+	fastembedEntry,
+	fastembedPackageDir,
+	arch = process.arch,
+	env = process.env,
+}: WindowsFastembedRuntimeOptions): Promise<WindowsFastembedRuntime> {
+	const nestedNodeModules = path.join(fastembedPackageDir, "node_modules");
+	const rootNodeModules = path.dirname(fastembedPackageDir);
+	const nestedOrtEntry = resolveRuntimeModule(nestedNodeModules, "onnxruntime-node");
+	const ortEntry = nestedOrtEntry ?? resolveRuntimeModule(rootNodeModules, "onnxruntime-node");
+	const ortPackageDir = path.join(nestedOrtEntry ? nestedNodeModules : rootNodeModules, "onnxruntime-node");
+	if (!ortEntry) {
+		throw new Error(`Cannot find module onnxruntime-node beside ${fastembedEntry}`);
+	}
+	const dllGlob = new Bun.Glob(`bin/napi-*/win32/${arch}/onnxruntime.dll`);
+	let dllDir: string | undefined;
+	for await (const dll of dllGlob.scan({ cwd: ortPackageDir, absolute: true, onlyFiles: true })) {
+		dllDir = path.dirname(dll);
+		break;
+	}
+	if (!dllDir) {
+		throw new Error(`Cannot find module onnxruntime-node Windows DLL for ${arch} beside ${ortEntry}`);
+	}
+
+	const currentPath = env.PATH;
+	const normalizedDllDir = path.resolve(dllDir).toLowerCase();
+	const alreadyPresent = currentPath
+		?.split(path.delimiter)
+		.some(entry => path.resolve(entry).toLowerCase() === normalizedDllDir);
+	if (!alreadyPresent) env.PATH = currentPath ? `${dllDir}${path.delimiter}${currentPath}` : dllDir;
+	return { ortEntry, ortPackageDir, dllDir };
+}
+
 export function loadFastembed(): Promise<FastembedModule> {
 	fastembedLoad ??= loadFastembedOnce().catch(error => {
 		fastembedLoad = null;
@@ -57,16 +118,14 @@ export function loadFastembed(): Promise<FastembedModule> {
 }
 
 async function loadFastembedOnce(): Promise<FastembedModule> {
-	// Dynamic imports: both packages are optional peers that eagerly load
-	// native addons and may be absent at runtime — a static import would load
-	// the addon at module-init and crash every consumer without the peers.
 	try {
-		// Preload the pinned ORT before fastembed's nested ORT — only on Windows,
-		// where loading the older binding first triggers a DLL-reuse crash.
-		if (process.platform === "win32") {
-			await import("onnxruntime-node");
+		const requireDirect = createRequire(import.meta.url);
+		const manifestPath = requireDirect.resolve("fastembed/package.json");
+		const manifest: { version?: unknown } = requireDirect(manifestPath);
+		if (manifest.version !== FASTEMBED_SPEC) {
+			throw new Error(`Cannot find package fastembed@${FASTEMBED_SPEC}; resolved ${String(manifest.version)}`);
 		}
-		return await import("fastembed");
+		return await loadResolvedFastembed(requireDirect.resolve("fastembed"), path.dirname(manifestPath));
 	} catch (error) {
 		if (!isRecoverableFastembedLoadError(error)) throw error;
 		logger.debug("mnemopi: fastembed not loadable, using on-demand runtime install", {
@@ -76,6 +135,16 @@ async function loadFastembedOnce(): Promise<FastembedModule> {
 	}
 }
 
+async function loadResolvedFastembed(entry: string, fastembedPackageDir: string): Promise<FastembedModule> {
+	const requireFastembed = createRequire(entry);
+	if (process.platform === "win32") {
+		const { ortEntry } = await prepareWindowsFastembedRuntime({ fastembedEntry: entry, fastembedPackageDir });
+		requireFastembed(ortEntry);
+	}
+	const loaded: FastembedModule = requireFastembed(entry);
+	return loaded;
+}
+
 async function loadFromRuntimeInstall(): Promise<FastembedModule> {
 	const plan = fastembedRuntimeInstallPlan();
 	const runtimeDir = await ensureRuntimeInstalled({
@@ -89,14 +158,9 @@ async function loadFromRuntimeInstall(): Promise<FastembedModule> {
 	// onnxruntime-node, @anush008/tokenizers → platform binding, …) through
 	// the runtime cache.
 	installRuntimeModuleResolver({ runtimeNodeModules: nodeModules });
-	if (process.platform === "win32") {
-		const ortEntry = resolveRuntimeModule(nodeModules, "onnxruntime-node");
-		if (ortEntry) createRequire(ortEntry)(ortEntry);
-	}
 	const entry = resolveRuntimeModule(nodeModules, "fastembed");
 	if (!entry) throw new Error(`fastembed runtime install at ${runtimeDir} has no loadable entry`);
-	const requireRuntime = createRequire(entry);
-	return requireRuntime(entry) as FastembedModule;
+	return loadResolvedFastembed(entry, path.join(nodeModules, "fastembed"));
 }
 
 function isRecoverableFastembedLoadError(error: unknown): boolean {