hippo-memory 1.64.0 → 1.64.1

package/README.md

@@ -994,7 +994,7 @@ Three benchmarks testing three different things. Full details in [`benchmarks/`]
 
 [LongMemEval](https://arxiv.org/abs/2410.10813) (ICLR 2025) is the industry-standard benchmark: 500 questions across 5 memory abilities, embedded in 115k+ token chat histories.
 
-**`hippo recall` (measured 2026-09-28 on hippo-memory 1.52.5).** On a default install, `hippo recall` puts an answer session in its top 5 for 85.6% of the 500 `_s` questions (95% CI 82.4 to 88.6), and 87.6% with the optional MiniLM embedder (84.6 to 90.4). Most of the gap to the scripts below is the default 4,000-token budget. Each memory in this test is a whole session, about 2,600 tokens at the median, so recall returns a median of 2 sessions. With the budget lifted, the same rankings score 96.8% (95.2 to 98.2) and 97.4% (96.0 to 98.6). A lifted call returns every candidate, a median of 47 sessions and 123,491 tokens per question, so those two figures measure the ranking, not an amount of text an agent could take in. Result: [`docs/evals/2026-09-28-recall-cli-longmemeval-result.md`](docs/evals/2026-09-28-recall-cli-longmemeval-result.md).
+**`hippo recall` (measured 2026-09-28 on hippo-memory 1.52.5, re-run 2026-10-06 on 1.64.0).** On a default install, `hippo recall` puts an answer session in its top 5 for 85.6% of the 500 `_s` questions (95% CI 82.4 to 88.6), and 87.8% with the optional MiniLM embedder (84.8 to 90.6; 87.6% on 1.52.5). Most of the gap to the scripts below is the default 4,000-token budget. Each memory in this test is a whole session, about 2,600 tokens at the median, so recall returns a median of 2 sessions. With the budget lifted, the same rankings score 96.8% (95.2 to 98.2) and 97.4% (96.0 to 98.6). A lifted call returns every candidate, a median of 47 sessions and 123,491 tokens per question, so those two figures measure the ranking, not an amount of text an agent could take in. Result: [`docs/evals/2026-09-28-recall-cli-longmemeval-result.md`](docs/evals/2026-09-28-recall-cli-longmemeval-result.md); re-run: [`docs/evals/2026-10-06-recall-cli-longmemeval-rerun-1.64.0.md`](docs/evals/2026-10-06-recall-cli-longmemeval-rerun-1.64.0.md).
 
 **The benchmark scripts (`_s` split; MiniLM re-measured 2026-09-23, voyage measured 2026-06-09).** Each question is scored against its own ~48-session haystack, the same way gbrain and other published systems report. The v1.23.0 pluggable embedding provider lets you choose the embedder:
 

package/dist/cli/maintenance.d.ts

@@ -1,4 +1,5 @@
+import { type EmbeddingProvider } from '../embedding-provider.js';
 export declare function cmdRefine(hippoRoot: string, flags: Record<string, string | boolean | string[]>): Promise<void>;
 export declare function cmdDedup(hippoRoot: string, flags: Record<string, string | boolean | string[]>): void;
-export declare function cmdEmbed(hippoRoot: string, flags: Record<string, string | boolean | string[]>): Promise<void>;
+export declare function cmdEmbed(hippoRoot: string, flags: Record<string, string | boolean | string[]>, given?: EmbeddingProvider): Promise<void>;
 //# sourceMappingURL=maintenance.d.ts.map

package/dist/cli/maintenance.js

@@ -3,7 +3,6 @@ import { envAnthropicApiKey } from '../env.js';
 import { loadAllEntries } from '../store/entry-reads.js';
 import { deduplicateStore } from '../dedupe.js';
 import { embedAll, loadEmbeddingIndex } from '../embeddings.js';
-import { resolveEmbeddingModel } from '../local-embedding.js';
 import { resolveEmbeddingProvider } from '../embedding-provider.js';
 import { resetAllPhysicsState } from '../physics-state.js';
 import { loadConfig } from '../config.js';
@@ -93,7 +92,7 @@ export function cmdDedup(hippoRoot, flags) {
 // ---------------------------------------------------------------------------
 // Embed command
 // ---------------------------------------------------------------------------
-export async function cmdEmbed(hippoRoot, flags) {
+export async function cmdEmbed(hippoRoot, flags, given) {
     // --global mirrors resolveAuthRoot (cli.ts:6900): initGlobal() + the global
     // root, skipping the local requireInit entirely, so this is the healing
     // path for pre-1.27.0 global stores from a directory with no local .hippo.
@@ -109,12 +108,13 @@ export async function cmdEmbed(hippoRoot, flags) {
         printEmbedStatus(root);
         return;
     }
-    if (!embedProviderReady(root))
+    const provider = readyEmbedProvider(root, given);
+    if (!provider)
         return;
     console.log('Embedding all memories (this may take a moment on first run to download model)...');
     let count;
     try {
-        count = await embedAll(root, resolveEmbeddingModel(root));
+        count = await embedAll(root, undefined, provider);
     }
     catch (err) {
         printError(`Embedding failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -126,6 +126,11 @@ export async function cmdEmbed(hippoRoot, flags) {
     const entriesAfter = loadAllEntries(root);
     const embIndexAfter = loadEmbeddingIndex(root);
     console.log(`Done. ${count} new embeddings created. ${Object.keys(embIndexAfter).length}/${entriesAfter.length} total.`);
+    const unembedded = entriesAfter.filter((e) => !embIndexAfter[e.id]).length;
+    if (unembedded > 0) {
+        printError(`${unembedded} memories are still not embedded (the warnings above name them). Re-run \`hippo embed\` to retry.`);
+        process.exitCode = 1;
+    }
 }
 function resetPhysics(root) {
     const entries = loadAllEntries(root);
@@ -154,10 +159,10 @@ function printEmbedStatus(root) {
         console.log(`  ${missing.length} memories need embedding (run \`hippo embed\` to embed them)`);
     }
 }
-/** False, after saying why, when no usable provider exists. */
-function embedProviderReady(root) {
+/** The provider to embed with, or null after saying why none is usable. */
+function readyEmbedProvider(root, given) {
     // Embedding (unlike status/reset) needs an available provider.
-    const embedProvider = (() => {
+    const embedProvider = given ?? (() => {
         try {
             return resolveEmbeddingProvider(root);
         }
@@ -168,23 +173,24 @@ function embedProviderReady(root) {
     })();
     if (!embedProvider) {
         process.exitCode = 1;
-        return false;
+        return null;
     }
     if (embedProvider.isAvailable())
-        return true;
+        return embedProvider;
     if (loadConfig(root).embeddings.enabled === false) {
         console.log('Embeddings are disabled in config (embeddings.enabled = false). Set it to true or "auto" to enable.');
-        return false;
+        return null;
     }
     if (embedProvider.kind === 'local') {
         console.log('Embeddings not available. Install @huggingface/transformers to enable:');
         console.log('  npm install @huggingface/transformers');
+        process.exitCode = 1;
     }
     else {
         printError(`Embedding provider '${embedProvider.kind}' is configured but ${embedProvider.keyEnv} is not set.`);
         printError(`Export ${embedProvider.keyEnv}, or set config.embeddings.provider back to 'local'.`);
         process.exitCode = 1;
     }
-    return false;
+    return null;
 }
 //# sourceMappingURL=maintenance.js.map

package/dist/embedding-provider.js

@@ -27,7 +27,7 @@
  * egress-blocked in the build sandbox).
  */
 import { envByName } from './env.js';
-import { getEmbedding, isEmbeddingAvailable, resolveEmbeddingModel, DEFAULT_EMBEDDING_MODEL, } from './local-embedding.js';
+import { getEmbedding, isEmbeddingAvailable, requireLocalPipeline, resolveEmbeddingModel, DEFAULT_EMBEDDING_MODEL, } from './local-embedding.js';
 import { loadConfig } from './config.js';
 import { redactSecretsStrict } from './secret-detect.js';
 import { fetchWithRetry } from './http-retry.js';
@@ -57,8 +57,9 @@ class LocalEmbeddingProvider {
         return this.enabled && isEmbeddingAvailable();
     }
     async embed(texts, role) {
-        // Sequential to preserve the historical single-pipeline behaviour and avoid
-        // contending the one cached pipeline instance with N concurrent calls.
+        // A model that cannot load fails the call, as an API outage does; items then run one at a time on the shared pipeline.
+        if (texts.length > 0)
+            await requireLocalPipeline(this.model);
         const out = [];
         for (const text of texts) {
             out.push(await getEmbedding(text, this.model, role));

package/dist/local-embedding.d.ts

@@ -7,6 +7,8 @@ export type EmbeddingRole = 'query' | 'passage';
 export declare function prefixFor(model: string, role?: EmbeddingRole): string;
 /** Check (synchronously) if @xenova/transformers or @huggingface/transformers is installed. */
 export declare function isEmbeddingAvailable(): boolean;
+/** Throws, with the reason, when the model's pipeline cannot load: a provider-level failure, not a per-item skip. */
+export declare function requireLocalPipeline(model: string): Promise<void>;
 export declare function resolveEmbeddingModel(hippoRoot: string, explicitModel?: string): string;
 /** Embeds `text` with the local model, or returns `[]` when Transformers.js is missing or fails; `role` adds e5-style prefixes. */
 export declare function getEmbedding(text: string, model?: string, role?: EmbeddingRole): Promise<number[]>;

package/dist/local-embedding.js

@@ -10,6 +10,7 @@ let _embeddingAvailable = null;
 // A pipeline is expensive to load, so one instance per model is kept for the process.
 const _pipelineInstances = new Map();
 const _pipelineLoading = new Map();
+const _pipelineErrors = new Map();
 export const DEFAULT_EMBEDDING_MODEL = 'Xenova/all-MiniLM-L6-v2';
 /** BGE was trained with CLS pooling; everything else gets mean, the sentence-transformers default, since CLS degrades mean-trained models. */
 export function poolingFor(model) {
@@ -79,8 +80,10 @@ async function loadPipeline(model) {
     const loading = (async () => {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const pkg = resolveTransformersPackage();
-        if (!pkg)
+        if (!pkg) {
+            _pipelineErrors.set(model, 'no transformers package is installed');
             return null;
+        }
         let pipelineFn = null;
         try {
             // SAFETY: the resolved module's shape is untyped by design (optional peer
@@ -98,11 +101,16 @@ async function loadPipeline(model) {
             pipelineFn = mod.pipeline ?? mod.default?.pipeline;
         }
         catch (err) {
-            log.debug(`transformers import failed (${pkg}): ${err instanceof Error ? err.message : String(err)}`);
+            // String(err) keeps a Node error's [ERR_...] code, which callers match on.
+            const reason = `transformers import failed (${pkg}): ${String(err)}`;
+            log.debug(reason);
+            _pipelineErrors.set(model, reason);
             return null;
         }
-        if (!pipelineFn)
+        if (!pipelineFn) {
+            _pipelineErrors.set(model, `${pkg} exports no pipeline function`);
             return null;
+        }
         // The offline bundle used in egress-blocked sandboxes ships only the FP32 model, so use whichever file is on disk.
         const cacheRoot = envModelCache();
         const quantized = !cacheRoot
@@ -113,7 +121,9 @@ async function loadPipeline(model) {
             return instance;
         }
         catch (err) {
-            log.debug(`embedding pipeline load failed (${model}): ${err instanceof Error ? err.message : String(err)}`);
+            const reason = `embedding pipeline load failed (${model}): ${String(err)}`;
+            log.debug(reason);
+            _pipelineErrors.set(model, reason);
             return null;
         }
         finally {
@@ -123,6 +133,12 @@ async function loadPipeline(model) {
     _pipelineLoading.set(model, loading);
     return loading;
 }
+/** Throws, with the reason, when the model's pipeline cannot load: a provider-level failure, not a per-item skip. */
+export async function requireLocalPipeline(model) {
+    if (await loadPipeline(model))
+        return;
+    throw new Error(`local embedding model did not load: ${_pipelineErrors.get(model) ?? 'unknown reason'}`);
+}
 export function resolveEmbeddingModel(hippoRoot, explicitModel) {
     const direct = explicitModel?.trim();
     if (direct)

package/dist/version.d.ts

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export declare const PACKAGE_VERSION = "1.64.0";
+export declare const PACKAGE_VERSION = "1.64.1";
 /** The floor a store takes on its first expiring key: the first release with schema v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export declare const EXPIRING_KEYS_MIN_BINARY = "1.64.0";
 /** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */

package/dist/version.js

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export const PACKAGE_VERSION = '1.64.0';
+export const PACKAGE_VERSION = '1.64.1';
 /** The floor a store takes on its first expiring key: the first release with schema v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export const EXPIRING_KEYS_MIN_BINARY = '1.64.0';
 /** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.64.0",
+  "version": "1.64.1",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.64.0",
+  "version": "1.64.1",
   "type": "module",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.64.0",
+  "version": "1.64.1",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.64.0",
+  "version": "1.64.1",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",