@prometheus-ai/memory 0.5.3 → 0.5.8

package/src/config.ts

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { hostMatchesUrl } from "@prometheus-ai/catalog/hosts";
 import {
 	type Env,
 	envBool,
@@ -15,13 +16,13 @@ import {
 export type { Env };
 export { envBool, envDisabled, envFloat, envInt, envOneOf, envOptionalString, envString, envTruthy };
 
-export const DEFAULT_DATA_DIR = join(homedir(), ".prometheus", "memory", "data");
-export const DEFAULT_DB_FILENAME = "prometheus-memory.db";
-export const FASTEMBED_CACHE_DIR = join(homedir(), ".prometheus", "cache", "fastembed");
-export const MODEL_CACHE_DIR = join(homedir(), ".prometheus", "memory", "models");
+export const DEFAULT_DATA_DIR = join(homedir(), ".hermes", "mnemopi", "data");
+export const DEFAULT_DB_FILENAME = "mnemopi.db";
+export const FASTEMBED_CACHE_DIR = join(homedir(), ".hermes", "cache", "fastembed");
+export const MODEL_CACHE_DIR = join(homedir(), ".hermes", "mnemopi", "models");
 
 export const DEFAULT_EMBEDDING_MODEL = "BAAI/bge-small-en-v1.5";
-export const DEFAULT_EMBEDDING_API_URL = "https://openrouter.ai/api/v1";
+export const DEFAULT_EMBEDDING_APROMETHEUS_URL = "https://openrouter.ai/api/v1";
 export const DEFAULT_LLM_MODEL_REPO = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF";
 export const DEFAULT_LLM_MODEL_FILE = "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf";
 export const HOST_LLM_TIMEOUT_SECONDS = 15.0;
@@ -57,7 +58,7 @@ export const VERACITY_WEIGHT_DEFAULTS = {
 } as const;
 
 export function dataDir(env: Env = process.env): string {
-	return envOptionalString("PROMETHEUS_MEMORY_DATA_DIR", env) ?? DEFAULT_DATA_DIR;
+	return envOptionalString("MNEMOPROMETHEUS_DATA_DIR", env) ?? DEFAULT_DATA_DIR;
 }
 
 export function dbPath(env: Env = process.env): string {
@@ -65,141 +66,149 @@ export function dbPath(env: Env = process.env): string {
 }
 
 export function beamOptimizationsEnabled(env: Env = process.env): boolean {
-	return envTruthy("PROMETHEUS_MEMORY_BEAM_OPTIMIZATIONS", env);
+	return envTruthy("MNEMOPROMETHEUS_BEAM_OPTIMIZATIONS", env);
 }
 
 export function embeddingModel(env: Env = process.env): string {
-	return envString("PROMETHEUS_MEMORY_EMBEDDING_MODEL", DEFAULT_EMBEDDING_MODEL, env);
+	return envString("MNEMOPROMETHEUS_EMBEDDING_MODEL", DEFAULT_EMBEDDING_MODEL, env);
 }
 
 export function embeddingDim(env: Env = process.env): number {
-	const explicit = envInt("PROMETHEUS_MEMORY_EMBEDDING_DIM", NaN, env);
+	const explicit = envInt("MNEMOPROMETHEUS_EMBEDDING_DIM", NaN, env);
 	if (Number.isFinite(explicit)) return explicit;
 	return EMBEDDING_DIMS[embeddingModel(env)] ?? 384;
 }
 
 export function embeddingApiKey(env: Env = process.env): string {
 	return envString(
-		"PROMETHEUS_MEMORY_EMBEDDING_API_KEY",
-		envString("OPENROUTER_API_KEY", envString("OPENAI_API_KEY", "", env), env),
+		"MNEMOPROMETHEUS_EMBEDDING_APROMETHEUS_KEY",
+		envString("OPENROUTER_APROMETHEUS_KEY", envString("OPENAI_APROMETHEUS_KEY", "", env), env),
 		env,
 	);
 }
 
 export function embeddingApiUrl(env: Env = process.env): string {
 	return envString(
-		"PROMETHEUS_MEMORY_EMBEDDING_API_URL",
-		envString("OPENROUTER_BASE_URL", DEFAULT_EMBEDDING_API_URL, env),
+		"MNEMOPROMETHEUS_EMBEDDING_APROMETHEUS_URL",
+		envString("OPENROUTER_BASE_URL", DEFAULT_EMBEDDING_APROMETHEUS_URL, env),
 		env,
 	);
 }
 
 export function embeddingsViaApi(env: Env = process.env): boolean {
-	return envTruthy("PROMETHEUS_MEMORY_EMBEDDINGS_VIA_API", env);
+	return envTruthy("MNEMOPROMETHEUS_EMBEDDINGS_VIA_API", env);
 }
 
 export function embeddingsDisabled(env: Env = process.env): boolean {
-	return envString("PROMETHEUS_MEMORY_NO_EMBEDDINGS", "", env) !== "";
+	return envString("MNEMOPROMETHEUS_NO_EMBEDDINGS", "", env) !== "";
 }
 
 export function isApiEmbeddingModel(model = embeddingModel(), env: Env = process.env): boolean {
 	if (model.startsWith("openai/") || model.includes("text-embedding") || model.startsWith("text-embedding"))
 		return true;
-	const baseUrl = envString("PROMETHEUS_MEMORY_EMBEDDING_API_URL", envString("OPENROUTER_BASE_URL", "", env), env);
-	if (baseUrl && !baseUrl.includes("openrouter.ai")) return true;
+	const baseUrl = envString(
+		"MNEMOPROMETHEUS_EMBEDDING_APROMETHEUS_URL",
+		envString("OPENROUTER_BASE_URL", "", env),
+		env,
+	);
+	if (baseUrl && !hostMatchesUrl(baseUrl, "openrouter")) return true;
 	return embeddingsViaApi(env);
 }
 
 export function apiEmbeddingsAvailable(env: Env = process.env): boolean {
 	if (embeddingsDisabled(env)) return false;
 	if (!isApiEmbeddingModel(embeddingModel(env), env)) return false;
-	const baseUrl = envString("PROMETHEUS_MEMORY_EMBEDDING_API_URL", envString("OPENROUTER_BASE_URL", "", env), env);
-	return Boolean(baseUrl && !baseUrl.includes("openrouter.ai")) || Boolean(embeddingApiKey(env));
+	const baseUrl = envString(
+		"MNEMOPROMETHEUS_EMBEDDING_APROMETHEUS_URL",
+		envString("OPENROUTER_BASE_URL", "", env),
+		env,
+	);
+	return Boolean(baseUrl && !hostMatchesUrl(baseUrl, "openrouter")) || Boolean(embeddingApiKey(env));
 }
 
 export function workingMemoryMaxItems(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_WM_MAX_ITEMS", 10000, env);
+	return envInt("MNEMOPROMETHEUS_WM_MAX_ITEMS", 10000, env);
 }
 
 export function workingMemoryTtlHours(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_WM_TTL_HOURS", 24, env);
+	return envInt("MNEMOPROMETHEUS_WM_TTL_HOURS", 24, env);
 }
 
 export function episodicRecallLimit(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_EP_LIMIT", 50000, env);
+	return envInt("MNEMOPROMETHEUS_EP_LIMIT", 50000, env);
 }
 
 export function sleepBatchSize(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_SLEEP_BATCH", 5000, env);
+	return envInt("MNEMOPROMETHEUS_SLEEP_BATCH", 5000, env);
 }
 
 export function scratchpadMaxItems(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_SP_MAX", 1000, env);
+	return envInt("MNEMOPROMETHEUS_SP_MAX", 1000, env);
 }
 
 export function recencyHalflifeHours(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_RECENCY_HALFLIFE", 168, env);
+	return envFloat("MNEMOPROMETHEUS_RECENCY_HALFLIFE", 168, env);
 }
 
 export function tier2Days(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_TIER2_DAYS", 30, env);
+	return envInt("MNEMOPROMETHEUS_TIER2_DAYS", 30, env);
 }
 
 export function tier3Days(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_TIER3_DAYS", 180, env);
+	return envInt("MNEMOPROMETHEUS_TIER3_DAYS", 180, env);
 }
 
 export function tier1Weight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_TIER1_WEIGHT", 1.0, env);
+	return envFloat("MNEMOPROMETHEUS_TIER1_WEIGHT", 1.0, env);
 }
 
 export function tier2Weight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_TIER2_WEIGHT", 0.5, env);
+	return envFloat("MNEMOPROMETHEUS_TIER2_WEIGHT", 0.5, env);
 }
 
 export function tier3Weight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_TIER3_WEIGHT", 0.25, env);
+	return envFloat("MNEMOPROMETHEUS_TIER3_WEIGHT", 0.25, env);
 }
 
 export function degradeBatchSize(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_DEGRADE_BATCH", 100, env);
+	return envInt("MNEMOPROMETHEUS_DEGRADE_BATCH", 100, env);
 }
 
 export function smartCompressEnabled(env: Env = process.env): boolean {
-	return !envDisabled("PROMETHEUS_MEMORY_SMART_COMPRESS", env);
+	return !envDisabled("MNEMOPROMETHEUS_SMART_COMPRESS", env);
 }
 
 export function tier3MaxChars(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_TIER3_MAX_CHARS", 300, env);
+	return envInt("MNEMOPROMETHEUS_TIER3_MAX_CHARS", 300, env);
 }
 
 export function statedWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_STATED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.stated, env);
+	return envFloat("MNEMOPROMETHEUS_STATED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.stated, env);
 }
 
 export function inferredWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_INFERRED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.inferred, env);
+	return envFloat("MNEMOPROMETHEUS_INFERRED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.inferred, env);
 }
 
 export function toolWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_TOOL_WEIGHT", VERACITY_WEIGHT_DEFAULTS.tool, env);
+	return envFloat("MNEMOPROMETHEUS_TOOL_WEIGHT", VERACITY_WEIGHT_DEFAULTS.tool, env);
 }
 
 export function importedWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_IMPORTED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.imported, env);
+	return envFloat("MNEMOPROMETHEUS_IMPORTED_WEIGHT", VERACITY_WEIGHT_DEFAULTS.imported, env);
 }
 
 export function unknownWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_UNKNOWN_WEIGHT", VERACITY_WEIGHT_DEFAULTS.unknown, env);
+	return envFloat("MNEMOPROMETHEUS_UNKNOWN_WEIGHT", VERACITY_WEIGHT_DEFAULTS.unknown, env);
 }
 
 export function veracityWeightOverrides(env: Env = process.env): string[] {
 	const names = [
-		"PROMETHEUS_MEMORY_STATED_WEIGHT",
-		"PROMETHEUS_MEMORY_INFERRED_WEIGHT",
-		"PROMETHEUS_MEMORY_TOOL_WEIGHT",
-		"PROMETHEUS_MEMORY_IMPORTED_WEIGHT",
-		"PROMETHEUS_MEMORY_UNKNOWN_WEIGHT",
+		"MNEMOPROMETHEUS_STATED_WEIGHT",
+		"MNEMOPROMETHEUS_INFERRED_WEIGHT",
+		"MNEMOPROMETHEUS_TOOL_WEIGHT",
+		"MNEMOPROMETHEUS_IMPORTED_WEIGHT",
+		"MNEMOPROMETHEUS_UNKNOWN_WEIGHT",
 	];
 	const overrides: string[] = [];
 	for (const name of names) {
@@ -209,19 +218,19 @@ export function veracityWeightOverrides(env: Env = process.env): string[] {
 }
 
 export function vecType(env: Env = process.env): VecType {
-	return envOneOf("PROMETHEUS_MEMORY_VEC_TYPE", ["float32", "int8", "bit"] as const, "int8", env);
+	return envOneOf("MNEMOPROMETHEUS_VEC_TYPE", ["float32", "int8", "bit"] as const, "int8", env);
 }
 
 export function vectorWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_VEC_WEIGHT", 0.5, env);
+	return envFloat("MNEMOPROMETHEUS_VEC_WEIGHT", 0.5, env);
 }
 
 export function ftsWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_FTS_WEIGHT", 0.3, env);
+	return envFloat("MNEMOPROMETHEUS_FTS_WEIGHT", 0.3, env);
 }
 
 export function importanceWeight(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_IMPORTANCE_WEIGHT", 0.2, env);
+	return envFloat("MNEMOPROMETHEUS_IMPORTANCE_WEIGHT", 0.2, env);
 }
 
 export function normalizedRecallWeights(
@@ -244,83 +253,104 @@ export function normalizedRecallWeights(
 }
 
 export function autoMigrateEnabled(env: Env = process.env): boolean {
-	return envString("PROMETHEUS_MEMORY_AUTO_MIGRATE", "1", env) !== "0";
+	return envString("MNEMOPROMETHEUS_AUTO_MIGRATE", "1", env) !== "0";
 }
 
 export function proactiveLinkingEnabled(env: Env = process.env): boolean {
-	return envString("PROMETHEUS_MEMORY_PROACTIVE_LINKING", "0", env) === "1";
+	return envString("MNEMOPROMETHEUS_PROACTIVE_LINKING", "0", env) === "1";
+}
+
+export interface RecallFeatureFlags {
+	polyphonicRecall?: boolean;
+	enhancedRecall?: boolean;
+}
+
+let polyphonicRecallDefault = false;
+let enhancedRecallDefault = false;
+
+/**
+ * Sets process-wide defaults for the env-gated recall features. Host configuration
+ * (e.g. the coding-agent `mnemopi.polyphonicRecall` / `mnemopi.enhancedRecall`
+ * settings) lands here; the `MNEMOPROMETHEUS_POLYPHONIC_RECALL` / `MNEMOPROMETHEUS_ENHANCED_RECALL`
+ * environment variables still win whenever they are set.
+ */
+export function configureRecallFeatures(flags: RecallFeatureFlags): void {
+	if (flags.polyphonicRecall !== undefined) polyphonicRecallDefault = flags.polyphonicRecall;
+	if (flags.enhancedRecall !== undefined) enhancedRecallDefault = flags.enhancedRecall;
 }
 
 export function polyphonicRecallEnabled(env: Env = process.env): boolean {
-	return envString("PROMETHEUS_MEMORY_POLYPHONIC_RECALL", "0", env) === "1";
+	const value = envOptionalString("MNEMOPROMETHEUS_POLYPHONIC_RECALL", env);
+	return value === undefined ? polyphonicRecallDefault : value === "1";
 }
 
 export function temporalHalflifeHours(env: Env = process.env): number {
-	return envFloat("PROMETHEUS_MEMORY_TEMPORAL_HALFLIFE_HOURS", 24, env);
+	return envFloat("MNEMOPROMETHEUS_TEMPORAL_HALFLIFE_HOURS", 24, env);
 }
 
 export function enhancedRecallEnabled(env: Env = process.env): boolean {
-	return envString("PROMETHEUS_MEMORY_ENHANCED_RECALL", "0", env) === "1";
+	const value = envOptionalString("MNEMOPROMETHEUS_ENHANCED_RECALL", env);
+	return value === undefined ? enhancedRecallDefault : value === "1";
 }
 
 export function llmEnabled(env: Env = process.env): boolean {
-	return envBool("PROMETHEUS_MEMORY_LLM_ENABLED", true, env);
+	return envBool("MNEMOPROMETHEUS_LLM_ENABLED", true, env);
 }
 
 export function llmMaxTokens(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_LLM_MAX_TOKENS", 2048, env);
+	return envInt("MNEMOPROMETHEUS_LLM_MAX_TOKENS", 2048, env);
 }
 
 export function llmThreads(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_LLM_N_THREADS", 4, env);
+	return envInt("MNEMOPROMETHEUS_LLM_N_THREADS", 4, env);
 }
 
 export function llmContext(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_LLM_N_CTX", 2048, env);
+	return envInt("MNEMOPROMETHEUS_LLM_N_CTX", 2048, env);
 }
 
 export function llmRepo(env: Env = process.env): string {
-	return envString("PROMETHEUS_MEMORY_LLM_REPO", DEFAULT_LLM_MODEL_REPO, env);
+	return envString("MNEMOPROMETHEUS_LLM_REPO", DEFAULT_LLM_MODEL_REPO, env);
 }
 
 export function llmFile(env: Env = process.env): string {
-	return envString("PROMETHEUS_MEMORY_LLM_FILE", DEFAULT_LLM_MODEL_FILE, env);
+	return envString("MNEMOPROMETHEUS_LLM_FILE", DEFAULT_LLM_MODEL_FILE, env);
 }
 
 export function llmModelFiles(env: Env = process.env): readonly [repo: string, file: string] {
-	const repo = envOptionalString("PROMETHEUS_MEMORY_LLM_REPO", env);
-	const file = envOptionalString("PROMETHEUS_MEMORY_LLM_FILE", env);
+	const repo = envOptionalString("MNEMOPROMETHEUS_LLM_REPO", env);
+	const file = envOptionalString("MNEMOPROMETHEUS_LLM_FILE", env);
 	return repo && file ? [repo, file] : [DEFAULT_LLM_MODEL_REPO, DEFAULT_LLM_MODEL_FILE];
 }
 
 export function llmBaseUrl(env: Env = process.env): string {
-	return envString("PROMETHEUS_MEMORY_LLM_BASE_URL", "", env).replace(/\/+$/, "");
+	return envString("MNEMOPROMETHEUS_LLM_BASE_URL", "", env).replace(/\/+$/, "");
 }
 
 export function llmApiKey(env: Env = process.env): string {
-	return envString("PROMETHEUS_MEMORY_LLM_API_KEY", "", env);
+	return envString("MNEMOPROMETHEUS_LLM_APROMETHEUS_KEY", "", env);
 }
 
 export function llmModel(env: Env = process.env): string {
-	return envString("PROMETHEUS_MEMORY_LLM_MODEL", "", env);
+	return envString("MNEMOPROMETHEUS_LLM_MODEL", "", env);
 }
 
 export function hostLlmEnabled(env: Env = process.env): boolean {
-	return envBool("PROMETHEUS_MEMORY_HOST_LLM_ENABLED", false, env);
+	return envBool("MNEMOPROMETHEUS_HOST_LLM_ENABLED", false, env);
 }
 
 export function hostLlmProvider(env: Env = process.env): string | undefined {
-	return envOptionalString("PROMETHEUS_MEMORY_HOST_LLM_PROVIDER", env);
+	return envOptionalString("MNEMOPROMETHEUS_HOST_LLM_PROVIDER", env);
 }
 
 export function hostLlmModel(env: Env = process.env): string | undefined {
-	return envOptionalString("PROMETHEUS_MEMORY_HOST_LLM_MODEL", env);
+	return envOptionalString("MNEMOPROMETHEUS_HOST_LLM_MODEL", env);
 }
 
 export function hostLlmContext(env: Env = process.env): number {
-	return envInt("PROMETHEUS_MEMORY_HOST_LLM_N_CTX", 32000, env);
+	return envInt("MNEMOPROMETHEUS_HOST_LLM_N_CTX", 32000, env);
 }
 
 export function sleepPrompt(env: Env = process.env): string {
-	return envString("PROMETHEUS_MEMORY_SLEEP_PROMPT", "", env).trim();
+	return envString("MNEMOPROMETHEUS_SLEEP_PROMPT", "", env).trim();
 }

package/src/core/banks.ts

@@ -4,9 +4,9 @@ import { join } from "node:path";
 import { dataDir as configuredDataDir } from "../config";
 import { closeQuietly, openDatabase } from "../db";
 
-export const DEFAULT_DATA_DIR = join(homedir(), ".prometheus", "memory", "data");
+export const DEFAULT_DATA_DIR = join(homedir(), ".hermes", "mnemopi", "data");
 export const BANKS_DIR = join(DEFAULT_DATA_DIR, "banks");
-const DB_FILENAME = "prometheus-memory.db";
+const DB_FILENAME = "mnemopi.db";
 
 export class ValueError extends Error {
 	override name = "ValueError";

package/src/core/beam/consolidate.ts

@@ -1,6 +1,7 @@
 import type { SQLQueryBindings } from "bun:sqlite";
 import { generateId, stableMemoryId } from "../../util/ids";
 import { aaakEncode } from "../aaak";
+import { EpisodicGraph } from "../episodic-graph";
 import { heuristicExtractFacts } from "../extraction";
 import { clampVeracity } from "../veracity-consolidation";
 import { scheduleEmbedding } from "./helpers";
@@ -51,11 +52,11 @@ function envInt(name: string, defaultValue: number): number {
 	return Number.isFinite(parsed) ? parsed : defaultValue;
 }
 
-const SLEEP_BATCH_SIZE = envInt("PROMETHEUS_MEMORY_SLEEP_BATCH", 5000);
-const TIER2_DAYS = envInt("PROMETHEUS_MEMORY_TIER2_DAYS", 30);
-const TIER3_DAYS = envInt("PROMETHEUS_MEMORY_TIER3_DAYS", 180);
-const DEGRADE_BATCH_SIZE = envInt("PROMETHEUS_MEMORY_DEGRADE_BATCH", 100);
-const TIER3_MAX_CHARS = envInt("PROMETHEUS_MEMORY_TIER3_MAX_CHARS", 300);
+const SLEEP_BATCH_SIZE = envInt("MNEMOPROMETHEUS_SLEEP_BATCH", 5000);
+const TIER2_DAYS = envInt("MNEMOPROMETHEUS_TIER2_DAYS", 30);
+const TIER3_DAYS = envInt("MNEMOPROMETHEUS_TIER3_DAYS", 180);
+const DEGRADE_BATCH_SIZE = envInt("MNEMOPROMETHEUS_DEGRADE_BATCH", 100);
+const TIER3_MAX_CHARS = envInt("MNEMOPROMETHEUS_TIER3_MAX_CHARS", 300);
 
 function isoNow(): string {
 	return new Date().toISOString();
@@ -261,6 +262,33 @@ function insertKg(
 	});
 }
 
+/**
+ * Populate the episodic graph (gists, facts, edges) for a freshly consolidated
+ * memory. The graph backs Polyphonic Recall's `graph` voice, which relies on
+ * `findGistsByParticipant`, `findFactsBySubject`, and `findRelatedMemories`.
+ *
+ * Best-effort: failures (closed DB, missing optional tables) MUST NOT roll back
+ * the consolidation that already wrote the episodic row, so any throw here is
+ * swallowed. Unlike the proactive-link path in `store.ts` this is unconditional
+ * — consolidation is the explicit "settle and compress" step where the graph
+ * is supposed to gain edges.
+ */
+function ingestIntoEpisodicGraph(beam: BeamMemoryState, memoryId: string, summary: string): void {
+	try {
+		const graph =
+			beam.episodicGraph instanceof EpisodicGraph
+				? beam.episodicGraph
+				: new EpisodicGraph({ db: beam.db, dbPath: beam.dbPath });
+		graph.ingestMemory(summary, memoryId, {
+			sessionId: sourceSession(beam),
+			linkExisting: true,
+			extractEntities: true,
+		});
+	} catch {
+		// Graph enrichment is best-effort and never blocks consolidation.
+	}
+}
+
 export function consolidateToEpisodic(
 	beam: BeamMemoryState,
 	summary: string,
@@ -299,6 +327,7 @@ export function consolidateToEpisodic(
 		],
 	);
 	extractAndStoreFacts(beam, summary, 0, memoryId);
+	ingestIntoEpisodicGraph(beam, memoryId, summary);
 	scheduleEmbedding(beam, [{ memoryId, content: summary }]);
 	emitEvent(beam, "MEMORY_CONSOLIDATED", memoryId, summary, source, importance, {
 		summary_of: [...sourceWmIds],

package/src/core/beam/helpers.ts

@@ -1,8 +1,9 @@
 import type { Database } from "bun:sqlite";
+import { logger } from "@prometheus-ai/utils";
 import { generateId as generateTimedId, sha256Hex16, stableMemoryId } from "../../util/ids";
 import { currentEmbeddingModel, embed } from "../embeddings";
-import { getMnemopiRuntimeOptions, withMnemopiRuntimeOptions } from "../runtime-options";
-import { cosineSimilarity as vectorCosineSimilarity } from "../vector-math";
+import { getMnemopiRuntimeOptions, mnemopiDebugEnabled, withMnemopiRuntimeOptions } from "../runtime-options";
+import { buildExactVectorIndex, searchExactVectorIndex } from "../vector-index";
 import type { BeamMemoryState, JsonValue, Metadata } from "./types";
 
 export type Vector = number[];
@@ -162,9 +163,9 @@ export function normalizeWeights(
 	ftsWeight: number | null | undefined,
 	importanceWeight: number | null | undefined,
 ): HybridWeights {
-	let vw = Math.max(0, vecWeight ?? envNumber("PROMETHEUS_MEMORY_VEC_WEIGHT", DEFAULT_WEIGHTS[0]));
-	let fw = Math.max(0, ftsWeight ?? envNumber("PROMETHEUS_MEMORY_FTS_WEIGHT", DEFAULT_WEIGHTS[1]));
-	let iw = Math.max(0, importanceWeight ?? envNumber("PROMETHEUS_MEMORY_IMPORTANCE_WEIGHT", DEFAULT_WEIGHTS[2]));
+	let vw = Math.max(0, vecWeight ?? envNumber("MNEMOPROMETHEUS_VEC_WEIGHT", DEFAULT_WEIGHTS[0]));
+	let fw = Math.max(0, ftsWeight ?? envNumber("MNEMOPROMETHEUS_FTS_WEIGHT", DEFAULT_WEIGHTS[1]));
+	let iw = Math.max(0, importanceWeight ?? envNumber("MNEMOPROMETHEUS_IMPORTANCE_WEIGHT", DEFAULT_WEIGHTS[2]));
 	if (!Number.isFinite(vw)) vw = 0;
 	if (!Number.isFinite(fw)) fw = 0;
 	if (!Number.isFinite(iw)) iw = 0;
@@ -551,16 +552,10 @@ export function inMemoryVecSearch(db: Database, queryEmbedding: readonly number[
 				LIMIT 10000
 			`)
 			.all() as Record<string, unknown>[];
-		const results: VectorDistanceResult[] = [];
-		for (const row of rows) {
-			const vec = decodeVector(String(row.embedding_json ?? ""));
-			if (vec === null) continue;
-			const sim = vectorCosineSimilarity(queryEmbedding, vec);
-			if (sim === 0 && (queryEmbedding.every(n => n === 0) || vec.every(n => n === 0))) continue;
-			results.push({ rowid: Number(row.rowid), distance: 1 - sim });
-		}
-		results.sort((a, b) => a.distance - b.distance || a.rowid - b.rowid);
-		return results.slice(0, Math.max(0, Math.trunc(k)));
+		const index = buildExactVectorIndex(
+			rows.map(row => ({ id: Number(row.rowid), vector: decodeVector(String(row.embedding_json ?? "")) })),
+		);
+		return searchExactVectorIndex(index, queryEmbedding, k).map(hit => ({ rowid: hit.id, distance: 1 - hit.score }));
 	} catch {
 		return [];
 	}
@@ -574,7 +569,7 @@ export function workingMemoryVecSearch(
 ): WorkingVectorResult[] {
 	if (queryEmbedding.length === 0) return [];
 	try {
-		const limit = process.env.PROMETHEUS_MEMORY_BEAM_MODE ? 500_000 : 50_000;
+		const limit = process.env.MNEMOPROMETHEUS_BEAM_MODE ? 500_000 : 50_000;
 		const rows = db
 			.query(`
 				SELECT wm.id, me.embedding_json
@@ -585,16 +580,10 @@ export function workingMemoryVecSearch(
 				LIMIT ?
 			`)
 			.all(now.toISOString(), limit) as Record<string, unknown>[];
-		const results: WorkingVectorResult[] = [];
-		for (const row of rows) {
-			const vec = decodeVector(String(row.embedding_json ?? ""));
-			if (vec === null) continue;
-			const sim = vectorCosineSimilarity(queryEmbedding, vec);
-			if (sim === 0 && (queryEmbedding.every(n => n === 0) || vec.every(n => n === 0))) continue;
-			results.push({ id: String(row.id), sim });
-		}
-		results.sort((a, b) => b.sim - a.sim || a.id.localeCompare(b.id));
-		return results.slice(0, Math.max(0, Math.trunc(k)));
+		const index = buildExactVectorIndex(
+			rows.map(row => ({ id: String(row.id), vector: decodeVector(String(row.embedding_json ?? "")) })),
+		);
+		return searchExactVectorIndex(index, queryEmbedding, k).map(hit => ({ id: hit.id, sim: hit.score }));
 	} catch {
 		return [];
 	}
@@ -944,12 +933,16 @@ async function runEmbedding(beam: BeamMemoryState, items: readonly EmbedItem[]):
 			}
 		});
 		insertMany(items);
-	} catch {
+	} catch (error) {
 		// Background embedding generation is best-effort: a failing provider, a closed DB
 		// during shutdown, or a transient API error must never disrupt the synchronous
 		// remember()/consolidate() that scheduled it. Production recall silently degrades
 		// to FTS-only for the affected rows, which is the same shape as a misconfigured
-		// provider.
+		// provider. Log so the failure is diagnosable (#2322).
+		logger[mnemopiDebugEnabled() ? "warn" : "debug"]("mnemopi: background embedding failed", {
+			itemCount: items.length,
+			error: String(error),
+		});
 	}
 }
 

package/src/core/beam/index.ts

@@ -87,14 +87,14 @@ function normalizeConfig(options: BeamMemoryOptions): BeamConfig {
 function autoMigrateAnnotations(db: Database, dbPath: string | undefined): void {
 	if (dbPath === undefined || dbPath === ":memory:" || !existsSync(dbPath)) return;
 	if (!hasPendingMigration(db)) return;
-	if (process.env.PROMETHEUS_MEMORY_AUTO_MIGRATE === "0") {
+	if (process.env.MNEMOPROMETHEUS_AUTO_MIGRATE === "0") {
 		const row = db
 			.query(
 				"SELECT COUNT(*) AS count FROM triples WHERE predicate IN ('mentions', 'fact', 'occurred_on', 'has_source')",
 			)
 			.get() as { count: number };
 		console.warn(
-			`PROMETHEUS_MEMORY_AUTO_MIGRATE=0: ${row.count} annotation rows pending; run scripts/migrate_triplestore_split.py manually.`,
+			`MNEMOPROMETHEUS_AUTO_MIGRATE=0: ${row.count} annotation rows pending; run scripts/migrate_triplestore_split.py manually.`,
 		);
 		return;
 	}