@prometheus-ai/memory 0.5.4 → 0.5.8

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.5.8] - 2026-06-14
+
+- Centralize embedding-heavy test opt-in so normal memory tests stay lightweight by default.
+
+## [0.5.2] - 2026-06-12
+
+- Clean up Prometheus package identity metadata.
+
+## [0.5.0] - 2026-06-11
+
+- Establish Prometheus public baseline for the package.

package/README.md

@@ -42,13 +42,13 @@ const ftsOnly = new PrometheusMemory({ noEmbeddings: true });
 const remoteEmbeddings = new PrometheusMemory({
 	embeddingModel: "text-embedding-3-small",
 	embeddingApiUrl: "https://api.openai.com/v1",
-	embeddingApiKey: process.env.OPENAI_API_KEY,
+	embeddingApiKey: process.env.OPENAI_APROMETHEUS_KEY,
 });
 
 const remoteLlm = new PrometheusMemory({
 	llm: {
 		baseUrl: "https://api.openai.com/v1",
-		apiKey: process.env.OPENAI_API_KEY,
+		apiKey: process.env.OPENAI_APROMETHEUS_KEY,
 		model: "gpt-4.1-mini",
 	},
 	// Equivalent aliases: llmBaseUrl, llmApiKey, llmModel.
@@ -85,8 +85,8 @@ Common environment fallbacks:
 - `PROMETHEUS_MEMORY_DATA_DIR` / `PROMETHEUS_MEMORY_DB_PATH`: default storage location.
 - `PROMETHEUS_MEMORY_NO_EMBEDDINGS=1`: force FTS-only recall.
 - `PROMETHEUS_MEMORY_EMBEDDING_MODEL`: defaults to `BAAI/bge-small-en-v1.5`.
-- `PROMETHEUS_MEMORY_EMBEDDING_API_URL` and `PROMETHEUS_MEMORY_EMBEDDING_API_KEY`: OpenAI-compatible embedding endpoint.
-- `PROMETHEUS_MEMORY_LLM_ENABLED=1`, `PROMETHEUS_MEMORY_LLM_BASE_URL`, `PROMETHEUS_MEMORY_LLM_API_KEY`, `PROMETHEUS_MEMORY_LLM_MODEL`: OpenAI-compatible LLM endpoint.
+- `PROMETHEUS_MEMORY_EMBEDDING_APROMETHEUS_URL` and `PROMETHEUS_MEMORY_EMBEDDING_APROMETHEUS_KEY`: OpenAI-compatible embedding endpoint.
+- `PROMETHEUS_MEMORY_LLM_ENABLED=1`, `PROMETHEUS_MEMORY_LLM_BASE_URL`, `PROMETHEUS_MEMORY_LLM_APROMETHEUS_KEY`, `PROMETHEUS_MEMORY_LLM_MODEL`: OpenAI-compatible LLM endpoint.
 
 Local embeddings use the `fastembed` npm package. Its default `BGESmallENV15` model is 384-dimensional and uses the package's CLS pooling plus vector normalization path. Local GGUF LLMs are not available in this package.
 

package/dist/types/config.d.ts

@@ -2,11 +2,11 @@ import { type Env, envBool, envDisabled, envFloat, envInt, envOneOf, envOptional
 export type { Env };
 export { envBool, envDisabled, envFloat, envInt, envOneOf, envOptionalString, envString, envTruthy };
 export declare const DEFAULT_DATA_DIR: string;
-export declare const DEFAULT_DB_FILENAME = "prometheus-memory.db";
+export declare const DEFAULT_DB_FILENAME = "mnemopi.db";
 export declare const FASTEMBED_CACHE_DIR: string;
 export declare const MODEL_CACHE_DIR: string;
 export declare const DEFAULT_EMBEDDING_MODEL = "BAAI/bge-small-en-v1.5";
-export declare const DEFAULT_EMBEDDING_API_URL = "https://openrouter.ai/api/v1";
+export declare const DEFAULT_EMBEDDING_APROMETHEUS_URL = "https://openrouter.ai/api/v1";
 export declare const DEFAULT_LLM_MODEL_REPO = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF";
 export declare const DEFAULT_LLM_MODEL_FILE = "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf";
 export declare const HOST_LLM_TIMEOUT_SECONDS = 15;
@@ -57,6 +57,17 @@ export declare function importanceWeight(env?: Env): number;
 export declare function normalizedRecallWeights(vec?: number, fts?: number, importance?: number): readonly [number, number, number];
 export declare function autoMigrateEnabled(env?: Env): boolean;
 export declare function proactiveLinkingEnabled(env?: Env): boolean;
+export interface RecallFeatureFlags {
+    polyphonicRecall?: boolean;
+    enhancedRecall?: boolean;
+}
+/**
+ * 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 declare function configureRecallFeatures(flags: RecallFeatureFlags): void;
 export declare function polyphonicRecallEnabled(env?: Env): boolean;
 export declare function temporalHalflifeHours(env?: Env): number;
 export declare function enhancedRecallEnabled(env?: Env): boolean;

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

@@ -18,6 +18,26 @@ type StoreRememberBatchOptions = RememberBatchOptions & {
     forceVeracity?: boolean;
     force_veracity?: boolean;
 };
+/**
+ * Reconcile stored embeddings against the active embedding model at store open.
+ *
+ * Every `memory_embeddings` row is stamped with the model that produced it (see
+ * `runEmbedding` in `helpers.ts`). When the configured embedding model changes,
+ * its vector dimension changes too, so the previously-stored vectors are no
+ * longer comparable. On a mismatch we wipe every stored vector — the
+ * `memory_embeddings` table, the `episodic_memory.binary_vector` column, and the
+ * sqlite-vec `vec_episodes` index — then enqueue all live memories for
+ * background re-embedding under the new model via `scheduleEmbedding`.
+ *
+ * Runs once per store open; a fresh store (no embeddings) or an already-current
+ * store is a no-op. The destructive wipe is skipped whenever it could not be
+ * rebuilt — embeddings disabled via the runtime option OR the
+ * `MNEMOPROMETHEUS_NO_EMBEDDINGS` env, or an unresolved (empty) active model — so a
+ * stale-but-valid corpus is never destroyed without a replacement. MUST run
+ * inside the active runtime-options scope so `currentEmbeddingModel()` /
+ * `embeddingsDisabled()` reflect the per-instance configuration.
+ */
+export declare function reconcileEmbeddingModel(beam: BeamMemoryState): void;
 export declare function remember(beam: BeamMemoryState, content: string, options?: StoreRememberOptions): string;
 export declare function rememberBatch(beam: BeamMemoryState, items: readonly RememberBatchItem[], options?: StoreRememberBatchOptions): string[];
 export declare function getContext(beam: BeamMemoryState, limit?: number): Row[];

package/dist/types/core/embeddings.d.ts

@@ -19,11 +19,12 @@ type LocalModelInitOptions = {
     showDownloadProgress?: boolean;
 };
 type LocalModelInitializer = (options: LocalModelInitOptions) => Promise<LocalEmbeddingModel>;
+export declare function embeddingsDisabled(): boolean;
 /**
  * Resolve the embedding model name for the currently active runtime scope.
  *
  * Reads (in order): the active provider's `model` from `withMnemopiRuntimeOptions`,
- * the `PROMETHEUS_MEMORY_EMBEDDING_MODEL` env var, then the bundled fastembed default. Stored
+ * the `MNEMOPROMETHEUS_EMBEDDING_MODEL` env var, then the bundled fastembed default. Stored
  * alongside each row in `memory_embeddings.model` so migrations can re-embed when
  * the active model changes.
  */

package/dist/types/core/extraction/client.d.ts

@@ -1,3 +1,4 @@
+import { type ApiKey, type FetchImpl } from "@prometheus-ai/ai";
 export declare const DEFAULT_EXTRACTION_MODEL: string;
 export declare const OPENROUTER_BASE_URL: string;
 export declare const FALLBACK_MODELS: readonly ["google/gemini-flash-latest"];
@@ -14,18 +15,21 @@ export interface ExtractedFact {
     confidence?: number;
     [key: string]: unknown;
 }
+export interface ExtractionClientOptions {
+    model?: string | null;
+    apiKey?: ApiKey | null;
+    baseUrl?: string | null;
+    fetch?: FetchImpl;
+}
 export declare class ExtractionClient {
     model: string;
-    apiKey: string;
+    apiKey: ApiKey;
     baseUrl: string;
     callCount: number;
-    constructor(opts?: {
-        model?: string | null;
-        apiKey?: string | null;
-        baseUrl?: string | null;
-    });
+    private readonly fetchImpl;
+    constructor(opts?: ExtractionClientOptions);
     chat(messages: readonly ChatMessage[], temperature?: number, maxTokens?: number): Promise<string>;
-    callApi(model: string, messages: readonly ChatMessage[], temperature: number, maxTokens: number): Promise<string>;
+    callApi(model: string, messages: readonly ChatMessage[], temperature: number, maxTokens: number, apiKey?: string): Promise<string>;
     extractFacts(messages: readonly ChatMessage[]): Promise<ExtractedFact[]>;
     xtractFacts(messages: readonly ChatMessage[]): Promise<ExtractedFact[]>;
 }

package/dist/types/core/extraction.d.ts

@@ -1,6 +1,7 @@
+import { type RemoteLlmOptions } from "./local-llm";
 export declare const EXTRACTION_PROMPT_TEMPLATE: string;
 export declare function buildExtractionPrompt(text: string, detectedLang?: string): string;
 export declare function parseFacts(rawOutput: string | null | undefined): string[];
 export declare function heuristicExtractFacts(text: string): string[];
-export declare function extractFacts(text: string | null | undefined): Promise<string[]>;
+export declare function extractFacts(text: string | null | undefined, options?: RemoteLlmOptions): Promise<string[]>;
 export declare function extractFactsSafe(text: string | null | undefined): Promise<string[]>;

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

@@ -0,0 +1,4 @@
+import type * as Fastembed from "fastembed";
+type FastembedModule = typeof Fastembed;
+export declare function loadFastembed(): Promise<FastembedModule>;
+export {};

package/dist/types/core/index.d.ts

@@ -1,3 +1,4 @@
+export { configureRecallFeatures, type RecallFeatureFlags } from "../config";
 export * from "./banks";
 export * from "./beam/index";
 export * from "./memory";

package/dist/types/core/llm-backends.d.ts

@@ -1,9 +1,11 @@
+import type { FetchImpl } from "@prometheus-ai/ai";
 export interface CompleteOptions {
     maxTokens?: number;
     temperature?: number;
     timeout?: number;
     provider?: string | null;
     model?: string | null;
+    fetch?: FetchImpl;
 }
 export interface LlmBackend {
     name?: string;

package/dist/types/core/local-llm.d.ts

@@ -1,4 +1,9 @@
+import { type FetchImpl } from "@prometheus-ai/ai";
+import { type CompleteOptions } from "./llm-backends";
 import { type MnemopiLlmCompleteOptions } from "./runtime-options";
+export interface RemoteLlmOptions {
+    fetch?: FetchImpl;
+}
 export declare const DEFAULT_MODEL_REPO: string;
 export declare const DEFAULT_MODEL_FILE: string;
 export declare function buildPrompt(memories: readonly string[], source?: string): string;
@@ -8,8 +13,8 @@ export declare function configuredLlmWillHandleCall(): boolean;
 export declare function cleanOutput(text: string): string;
 export declare function chunkMemoriesByBudget(memories: readonly string[], source?: string): string[][];
 export declare function llmAvailable(): boolean;
-export declare function callRemoteLlm(prompt: string, temperature?: number): Promise<string | null>;
+export declare function callRemoteLlm(prompt: string, temperature?: number, options?: RemoteLlmOptions): Promise<string | null>;
 export declare function localGgufAvailable(): false;
 export declare function callLocalLlm(_prompt: string): Promise<string | null>;
-export declare function summarizeMemories(memories: readonly string[], source?: string): Promise<string | null>;
-export declare function complete(prompt: string, temperature?: number): Promise<string | null>;
+export declare function summarizeMemories(memories: readonly string[], source?: string, options?: RemoteLlmOptions): Promise<string | null>;
+export declare function complete(prompt: string, temperature?: number, options?: CompleteOptions): Promise<string | null>;

package/dist/types/core/memory.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from "bun:sqlite";
-import type { Api, Model } from "@prometheus-ai/ai";
+import type { Api, ApiKey, Model } from "@prometheus-ai/ai";
 import type { MemoryInput, Metadata } from "../types";
 import { BeamMemory } from "./beam/index";
 import type { RecallEnhancedOptions, RecallOptions, RecallResult, SleepResult } from "./beam/types";
@@ -20,13 +20,22 @@ export interface MnemopiOptions {
     readonly noEmbeddings?: boolean;
     readonly embeddingModel?: string;
     readonly embeddingApiUrl?: string;
-    readonly embeddingApiKey?: string;
+    readonly embeddingApiKey?: ApiKey;
     readonly embeddings?: false | MnemopiEmbeddingRuntimeOptions;
     readonly llmEnabled?: boolean;
     readonly llmBaseUrl?: string;
-    readonly llmApiKey?: string;
+    readonly llmApiKey?: ApiKey;
     readonly llmModel?: string | Model<Api>;
     readonly llm?: false | MnemopiLlmRuntimeOptions | Model<Api> | MnemopiLlmCompletion;
+    /** Escalate best-effort failure logs (embedding pipeline) from debug to warn. */
+    readonly debug?: boolean;
+    /**
+     * When `false`, skip the embedding-model reconcile (wipe-and-rebuild) on open.
+     * Read-only / ephemeral consumers (e.g. a stats snapshot) set this so an open
+     * never triggers a destructive migration whose background rebuild the process
+     * would exit before completing. Defaults to `true`.
+     */
+    readonly reconcile?: boolean;
 }
 export interface RememberInput extends MemoryInput {
     readonly extract?: boolean;

package/dist/types/core/query-cache.d.ts

@@ -1,3 +1,4 @@
+import { type Env } from "../config";
 export type QueryCacheResult = Record<string, unknown>;
 export type QueryEmbedding = readonly number[];
 export interface QueryCacheOptions {
@@ -20,7 +21,6 @@ export interface QueryCacheStats {
     readonly max_size: number;
     readonly version: number;
 }
-type Env = Readonly<Record<string, string | undefined>>;
 export declare function isEnhancedRecallEnabled(env?: Env): boolean;
 export declare function isQueryCacheEnabled(useCache?: boolean, env?: Env): boolean;
 export declare class QueryCache {
@@ -43,4 +43,3 @@ export declare class QueryCache {
     normalize(query: string): string;
     jaccardWords(queryA: string, queryB: string): number;
 }
-export {};

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

@@ -1,4 +1,4 @@
-import type { Api, Model } from "@prometheus-ai/ai";
+import type { Api, ApiKey, Model } from "@prometheus-ai/ai";
 export interface MnemopiLlmCompleteOptions {
     maxTokens?: number;
     temperature?: number;
@@ -22,13 +22,13 @@ export interface MnemopiEmbeddingRuntimeOptions {
     disabled?: boolean;
     model?: string;
     apiUrl?: string;
-    apiKey?: string;
+    apiKey?: ApiKey;
     provider?: MnemopiEmbeddingProvider | ((texts: readonly string[]) => EmbeddingOutput | Promise<EmbeddingOutput>);
 }
 export interface MnemopiLlmRuntimeOptions {
     enabled?: boolean;
     baseUrl?: string;
-    apiKey?: string;
+    apiKey?: ApiKey;
     model?: string | Model<Api>;
     maxTokens?: number;
     complete?: MnemopiLlmCompletion;
@@ -40,18 +40,20 @@ export interface MnemopiLlmRuntimeOptions {
 export interface MnemopiRuntimeOptions {
     embeddings?: false | MnemopiEmbeddingRuntimeOptions;
     llm?: false | MnemopiLlmRuntimeOptions | Model<Api> | MnemopiLlmCompletion;
+    /** Verbose diagnostics: escalates best-effort failure logs from debug to warn. */
+    debug?: boolean;
 }
 export interface ResolvedMnemopiEmbeddingRuntimeOptions {
     disabled?: boolean;
     model?: string;
     apiUrl?: string;
-    apiKey?: string;
+    apiKey?: ApiKey;
     provider?: MnemopiEmbeddingProvider;
 }
 export interface ResolvedMnemopiLlmRuntimeOptions {
     enabled?: boolean;
     baseUrl?: string;
-    apiKey?: string;
+    apiKey?: ApiKey;
     model?: string | Model<Api>;
     maxTokens?: number;
     complete?: MnemopiLlmCompletion;
@@ -61,8 +63,11 @@ export interface ResolvedMnemopiLlmRuntimeOptions {
 export interface ResolvedMnemopiRuntimeOptions {
     embeddings?: ResolvedMnemopiEmbeddingRuntimeOptions;
     llm?: ResolvedMnemopiLlmRuntimeOptions;
+    debug?: boolean;
 }
 export declare function withMnemopiRuntimeOptions<T>(options: ResolvedMnemopiRuntimeOptions | undefined, fn: () => T): T;
 export declare function getMnemopiRuntimeOptions(): ResolvedMnemopiRuntimeOptions | undefined;
+/** Whether the active runtime scope requested verbose diagnostics (`mnemopi.debug`). */
+export declare function mnemopiDebugEnabled(): boolean;
 export declare function resolveEmbeddingProvider(provider: MnemopiEmbeddingProvider | ((texts: readonly string[]) => EmbeddingOutput | Promise<EmbeddingOutput>) | undefined): MnemopiEmbeddingProvider | undefined;
 export declare function isPiAiModel(value: unknown): value is Model<Api>;

package/dist/types/core/shmr.d.ts

@@ -44,13 +44,19 @@ type BeamLike = {
 };
 export declare const FACTS_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS harmonic_beliefs (\n\tbelief_id TEXT PRIMARY KEY,\n\tsubject TEXT,\n\tpredicate TEXT,\n\tobject TEXT NOT NULL,\n\tconfidence REAL DEFAULT 0.5,\n\tprovenance TEXT,\n\tcluster_id TEXT,\n\titeration INTEGER DEFAULT 0,\n\tcreated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n\tupdated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n);\nCREATE TABLE IF NOT EXISTS memory_resonance_log (\n\tid INTEGER PRIMARY KEY AUTOINCREMENT,\n\tsession_id TEXT,\n\tcluster_count INTEGER,\n\tbeliefs_generated INTEGER,\n\tcontradictions_resolved INTEGER,\n\tharmony_score_avg REAL,\n\tduration_ms INTEGER,\n\tcreated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n);\nCREATE INDEX IF NOT EXISTS idx_beliefs_subject ON harmonic_beliefs(subject);\nCREATE INDEX IF NOT EXISTS idx_beliefs_predicate ON harmonic_beliefs(predicate);\nCREATE INDEX IF NOT EXISTS idx_beliefs_confidence ON harmonic_beliefs(confidence);\n";
 export declare function initSchema(db: Database): void;
-export declare function embed(text: string): Vector;
-export declare function clusterBySimilarity(items: readonly ShmrItem[], threshold: number): ShmrItem[][];
+/**
+ * Embed a batch of texts with the configured embedding provider. Falls back to the
+ * deterministic SHA1 bag-of-words hash for the entire batch when no provider is
+ * available or the provider fails, so every returned vector shares one space.
+ */
+export declare function embedBatch(texts: readonly string[]): Promise<Vector[]>;
+export declare function embed(text: string): Promise<Vector>;
+export declare function clusterBySimilarity(items: readonly ShmrItem[], threshold: number): Promise<ShmrItem[][]>;
 export declare function formatClusterForLlm(cluster: readonly ShmrItem[]): string;
 export declare function extractJsonFromLlmOutput(text: string): Belief[];
-export declare function computeHarmonyScore(beliefs: readonly Belief[], cluster: readonly ShmrItem[]): number;
+export declare function computeHarmonyScore(beliefs: readonly Belief[], cluster: readonly ShmrItem[]): Promise<number>;
 export declare function applyBeliefs(db: Database, beliefs: readonly Belief[], cluster: readonly ShmrItem[], clusterId: string): void;
-export declare function harmonize(beam: BeamLike, batchSize?: number, maxIterations?: number, similarityThreshold?: number): HarmonizeStats;
-export declare function recallBeliefs(beam: BeamLike, query: string, topK?: number): Array<Record<string, unknown>>;
+export declare function harmonize(beam: BeamLike, batchSize?: number, maxIterations?: number, similarityThreshold?: number): Promise<HarmonizeStats>;
+export declare function recallBeliefs(beam: BeamLike, query: string, topK?: number): Promise<Array<Record<string, unknown>>>;
 export declare function reflect(_beam: BeamLike | null, _question: string, facts?: Array<Record<string, unknown>> | null, topK?: number): string | null;
 export declare function getResonanceLog(beam: BeamLike, limit?: number): Array<Record<string, unknown>>;

package/dist/types/core/vector-index.d.ts

@@ -0,0 +1,16 @@
+export interface ExactVectorSearchHit<TId> {
+    id: TId;
+    score: number;
+}
+export interface ExactVectorIndex<TId> {
+    readonly ids: readonly TId[];
+    readonly matrix: Float32Array;
+    readonly dimensions: number;
+    readonly count: number;
+}
+export interface VectorIndexRow<TId> {
+    id: TId;
+    vector: readonly number[] | null | undefined;
+}
+export declare function buildExactVectorIndex<TId>(rows: readonly VectorIndexRow<TId>[]): ExactVectorIndex<TId>;
+export declare function searchExactVectorIndex<TId>(index: ExactVectorIndex<TId>, query: readonly number[], limit: number): ExactVectorSearchHit<TId>[];

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
+export { configureRecallFeatures, type RecallFeatureFlags } from "./config";
 export * from "./core/beam/index";
 export * from "./core/embeddings";
 export * from "./core/llm-backends";
 export * from "./core/memory";
-export { addMemory, flushExtractions, forget, get, getBank, getContext, getDefaultInstance, getStats, Mnemopi, Mnemopi as PrometheusMemory, query, recall, recallEnhanced, remember, resetDefaultInstanceForTests, resetMemoryForTests, resetModuleStateForTests, saveMemory, scratchpadClear, scratchpadRead, scratchpadWrite, search, setBank, sleep, sleepAllSessions, storeMemory, update, } from "./core/memory";
+export { addMemory, flushExtractions, forget, get, getBank, getContext, getDefaultInstance, getStats, Mnemopi, query, recall, recallEnhanced, remember, resetDefaultInstanceForTests, resetMemoryForTests, resetModuleStateForTests, saveMemory, scratchpadClear, scratchpadRead, scratchpadWrite, search, setBank, sleep, sleepAllSessions, storeMemory, update, } from "./core/memory";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@prometheus-ai/memory",
-	"version": "0.5.4",
+	"version": "0.5.8",
 	"description": "Local SQLite memory engine for Prometheus agents",
 	"homepage": "https://prometheus.trivlab.com",
 	"author": "Uttam Trivedi",
@@ -36,14 +36,27 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@prometheus-ai/ai": "0.5.4",
-		"@prometheus-ai/utils": "0.5.4",
+		"@prometheus-ai/ai": "0.5.8",
+		"@prometheus-ai/catalog": "0.5.8",
+		"@prometheus-ai/utils": "0.5.8",
+		"lru-cache": "11.5.1"
+	},
+	"peerDependencies": {
 		"fastembed": "2.1.0",
-		"lru-cache": "11.5.1",
-		"onnxruntime-node": "1.24.3"
+		"onnxruntime-node": "1.26.0"
+	},
+	"peerDependenciesMeta": {
+		"fastembed": {
+			"optional": true
+		},
+		"onnxruntime-node": {
+			"optional": true
+		}
 	},
 	"devDependencies": {
-		"@types/bun": "^1.3.14"
+		"@types/bun": "^1.3.14",
+		"fastembed": "2.1.0",
+		"onnxruntime-node": "1.26.0"
 	},
 	"engines": {
 		"bun": ">=1.3.14"
@@ -51,6 +64,7 @@
 	"files": [
 		"src",
 		"README.md",
+		"CHANGELOG.md",
 		"dist/types"
 	],
 	"exports": {
@@ -62,6 +76,10 @@
 			"types": "./dist/types/core/index.d.ts",
 			"import": "./src/core/index.ts"
 		},
+		"./core/beam": {
+			"types": "./dist/types/core/beam/index.d.ts",
+			"import": "./src/core/beam/index.ts"
+		},
 		"./beam": {
 			"types": "./dist/types/core/beam/index.d.ts",
 			"import": "./src/core/beam/index.ts"
@@ -77,6 +95,11 @@
 		"./cli": {
 			"types": "./dist/types/cli.d.ts",
 			"import": "./src/cli.ts"
-		}
+		},
+		"./*": {
+			"types": "./dist/types/*.d.ts",
+			"import": "./src/*.ts"
+		},
+		"./*.js": "./src/*.ts"
 	}
 }

package/src/cli.ts

@@ -68,7 +68,7 @@ function resolveDataDir(context?: CliContext): string {
 }
 
 function resolveDbPath(context?: CliContext): string {
-	return context?.dbPath ?? (context?.dataDir ? join(context.dataDir, "prometheus-memory.db") : configuredDbPath());
+	return context?.dbPath ?? (context?.dataDir ? join(context.dataDir, "mnemopi.db") : configuredDbPath());
 }
 
 function getMemory(context?: CliContext): { memory: BeamMemory; owned: boolean } {
@@ -82,7 +82,7 @@ async function withMemory<T>(context: CliContext | undefined, fn: (memory: BeamM
 	try {
 		const result = await fn(memory);
 		// Drain background fact-extraction and embedding tasks before close so
-		// short-lived owners (e.g. `prometheus-memory store …` / `prometheus-memory sleep …`) don't
+		// short-lived owners (e.g. `mnemopi store …` / `mnemopi sleep …`) don't
 		// race the SQLite handle shut from under in-flight `embed()` writes.
 		if (owned) await memory.flushExtractions();
 		return result;
@@ -130,7 +130,7 @@ function formatImportStats(stats: ImportStats): string {
 }
 
 export const cmdExport: CommandHandler = (args, context) => {
-	if (args.length === 0) usage("Usage: prometheus-memory export <file.json>");
+	if (args.length === 0) usage("Usage: mnemopi export <file.json>");
 	const outputPath = args[0] ?? "";
 	return withMemory(context, memory => {
 		mkdirSync(dirname(outputPath), { recursive: true });
@@ -149,7 +149,7 @@ export const cmdExport: CommandHandler = (args, context) => {
 };
 
 export const cmdImport: CommandHandler = (args, context) => {
-	if (args.length === 0) usage("Usage: prometheus-memory import <file.json>");
+	if (args.length === 0) usage("Usage: mnemopi import <file.json>");
 	const inputPath = args[0] ?? "";
 	if (!existsSync(inputPath)) fail(`Import file not found: ${inputPath}`, 1);
 	let parsed: unknown;
@@ -160,7 +160,7 @@ export const cmdImport: CommandHandler = (args, context) => {
 		throw error;
 	}
 	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
-		fail("Import file must contain a Prometheus Memory export object", 1);
+		fail("Import file must contain a Mnemopi export object", 1);
 	return withMemory(context, memory => {
 		const stats = memory.importFromDict(parsed as Record<string, unknown>);
 		out(context, `Imported ${formatImportStats(stats)} from ${inputPath}`);
@@ -174,7 +174,7 @@ export const cmdMcp: CommandHandler = async args => {
 };
 
 export const cmdRemember: CommandHandler = (args, context) => {
-	if (args.length === 0) usage("Usage: prometheus-memory store <content> [source] [importance]");
+	if (args.length === 0) usage("Usage: mnemopi store <content> [source] [importance]");
 	const content = args[0] ?? "";
 	const source = args[1] ?? "cli";
 	const importance = args[2] === undefined ? 0.5 : parseFloatArg(args[2], "importance");
@@ -186,7 +186,7 @@ export const cmdRemember: CommandHandler = (args, context) => {
 };
 
 export const cmdRecall: CommandHandler = async (args, context) => {
-	if (args.length === 0) usage("Usage: prometheus-memory recall <query> [top_k]");
+	if (args.length === 0) usage("Usage: mnemopi recall <query> [top_k]");
 	const query = args[0] ?? "";
 	const topK = args[1] === undefined ? 5 : parseIntArg(args[1], "top_k");
 	const { memory, owned } = getMemory(context);
@@ -209,7 +209,7 @@ export const cmdRecall: CommandHandler = async (args, context) => {
 };
 
 export const cmdUpdate: CommandHandler = (args, context) => {
-	if (args.length < 2) usage("Usage: prometheus-memory update <memory_id> <new_content> [importance]");
+	if (args.length < 2) usage("Usage: mnemopi update <memory_id> <new_content> [importance]");
 	const memoryId = args[0] ?? "";
 	const content = args[1] ?? "";
 	const importance = args[2] === undefined ? null : parseFloatArg(args[2], "importance");
@@ -221,7 +221,7 @@ export const cmdUpdate: CommandHandler = (args, context) => {
 };
 
 export const cmdDelete: CommandHandler = (args, context) => {
-	if (args.length === 0) usage("Usage: prometheus-memory delete <memory_id>");
+	if (args.length === 0) usage("Usage: mnemopi delete <memory_id>");
 	const memoryId = args[0] ?? "";
 	return withMemory(context, memory => {
 		if (!memory.forgetWorking(memoryId)) fail(`Memory not found: ${memoryId}`, 1);
@@ -237,7 +237,7 @@ export const cmdStats: CommandHandler = (_args, context) =>
 		const wm = beam.working_memory ?? {};
 		const ep = beam.episodic_memory ?? {};
 		const triples = beam.triples ?? {};
-		out(context, "\nPrometheus Memory Stats\n");
+		out(context, "\nMnemopi Stats\n");
 		out(context, `  Total memories: ${asCount(stats.total_memories)}`);
 		out(context, `  Working memory: ${asCount(wm.total)}`);
 		out(context, `  Episodic memory: ${asCount(ep.total)}`);
@@ -256,7 +256,7 @@ export const cmdSleep: CommandHandler = (_args, context) =>
 	});
 
 export const cmdScratchpad: CommandHandler = (args, context) => {
-	if (args.length === 0) usage("Usage: prometheus-memory scratchpad <read|write|clear> [content]");
+	if (args.length === 0) usage("Usage: mnemopi scratchpad <read|write|clear> [content]");
 	const subcmd = args[0];
 	return withMemory(context, memory => {
 		if (subcmd === "read") {
@@ -267,7 +267,7 @@ export const cmdScratchpad: CommandHandler = (args, context) => {
 			return 0;
 		}
 		if (subcmd === "write") {
-			if (args.length < 2) usage("Usage: prometheus-memory scratchpad write <content>");
+			if (args.length < 2) usage("Usage: mnemopi scratchpad write <content>");
 			const id = memory.scratchpadWrite(args[1] ?? "");
 			out(context, `Scratchpad stored: ${id}`);
 			return 0;
@@ -282,7 +282,7 @@ export const cmdScratchpad: CommandHandler = (args, context) => {
 };
 
 export const cmdBank: CommandHandler = (args, context) => {
-	if (args.length === 0) usage("Usage: prometheus-memory bank <list|create|delete> [name]");
+	if (args.length === 0) usage("Usage: mnemopi bank <list|create|delete> [name]");
 	const manager = new BankManager(resolveDataDir(context));
 	const subcmd = args[0];
 	try {
@@ -292,14 +292,14 @@ export const cmdBank: CommandHandler = (args, context) => {
 			return 0;
 		}
 		if (subcmd === "create") {
-			if (args.length < 2) fail("Usage: prometheus-memory bank create <name>");
+			if (args.length < 2) fail("Usage: mnemopi bank create <name>");
 			const name = args[1] ?? "";
 			manager.createBank(name);
 			out(context, `Created bank: ${name}`);
 			return 0;
 		}
 		if (subcmd === "delete") {
-			if (args.length < 2) fail("Usage: prometheus-memory bank delete <name>");
+			if (args.length < 2) fail("Usage: mnemopi bank delete <name>");
 			const name = args[1] ?? "";
 			if (!manager.deleteBank(name)) fail(`Bank not found: ${name}`, 1);
 			out(context, `Deleted bank: ${name}`);
@@ -318,7 +318,7 @@ export const cmdDiagnose: CommandHandler = (_args, context) => {
 		dbPath: resolveDbPath(context),
 		dataDir: resolveDataDir(context),
 	});
-	out(context, "\nPrometheus Memory Diagnostics\n");
+	out(context, "\nMnemopi Diagnostics\n");
 	out(context, `  Checks passed: ${result.checks_passed}/${result.checks_total}`);
 	if (result.key_findings.length > 0) {
 		out(context, "\n  Key findings:");
@@ -352,8 +352,8 @@ export const COMMANDS: Readonly<Record<string, CommandHandler>> = {
 };
 
 export function printHelp(context?: CliContext): void {
-	out(context, "Prometheus Memory - Local AI Memory System\n");
-	out(context, "Usage: prometheus-memory <command> [args]\n");
+	out(context, "Mnemopi - Local AI Memory System\n");
+	out(context, "Usage: mnemopi <command> [args]\n");
 	out(context, "Commands:");
 	out(context, "  store <content> [source] [importance]  Store a memory");
 	out(context, "  recall <query> [top_k]                 Search memories");
@@ -378,7 +378,7 @@ export async function runCli(args: readonly string[] = Bun.argv.slice(2), contex
 	const handler = COMMANDS[command];
 	if (!handler) {
 		err(context, `Unknown command: ${command}`);
-		err(context, "Run 'prometheus-memory --help' for usage.");
+		err(context, "Run 'mnemopi --help' for usage.");
 		return 2;
 	}
 	try {