hippo-memory 1.52.2 → 1.52.4

package/README.md

@@ -1,13 +1,15 @@
-# 🦛 Hippo
+# 🦛 Hippo: memory for AI agents that learns what is wrong
 
 **Hippo learns what is wrong and stops repeating it.** Good memory is knowing what to forget: what turned out wrong, what got replaced, what nobody used.
 
 [![npm](https://img.shields.io/npm/v/hippo-memory)](https://npmjs.com/package/hippo-memory)
-[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+[![npm downloads](https://img.shields.io/npm/dm/hippo-memory)](https://npmjs.com/package/hippo-memory)
+[![CI](https://github.com/kitfunso/hippo-memory/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/kitfunso/hippo-memory/actions/workflows/ci.yml)
+[![license](https://img.shields.io/badge/license-MIT-blue)](https://github.com/kitfunso/hippo-memory/blob/master/LICENSE)
 [![website](https://img.shields.io/badge/website-hippo--memory.com-7c3aed)](https://hippo-memory.com)
 
 <p align="center">
-  <img src="./assets/hippo-init.svg" alt="hippo init --scan ~ — initializing memory across all repos" width="720">
+  <img src="https://raw.githubusercontent.com/kitfunso/hippo-memory/master/assets/hippo-init.svg" alt="hippo init --scan ~ initializing memory across all repos" width="720">
 </p>
 
 A memory layer for AI agents. Mark a memory wrong and it stops coming back. A newer fact replaces the old one. Memories you use get stronger. Provenance on every memory. SQLite under the hood, zero runtime deps, works with every CLI agent you have.
@@ -27,6 +29,8 @@ Storage:       SQLite backbone with markdown mirrors. Git-trackable, human-reada
 Dependencies:  Zero runtime deps. Node.js 22.16+. Optional embeddings: bring-your-own local Transformers.js (`npm i @huggingface/transformers`, or legacy `@xenova/transformers`) or an opt-in API embedder (OpenAI/Voyage/Cohere). Nothing is auto-installed.
 ```
 
+**Contents:** [Why](#why-this-exists) · [Receipts](#receipts) · [Quick start](#quick-start) · [Agent setup](#framework-integrations) · [MCP server](#mcp-server) · [How it works](#how-it-works) · [Features](#key-features) · [CLI](#cli-reference) · [Comparison](#comparison) · [Benchmarks](#benchmarks) · [FAQ](#faq) · [Contributing](#contributing)
+
 ---
 
 ## Why this exists
@@ -112,7 +116,7 @@ hippo init
 #    Auto-installed claude-code hook in CLAUDE.md
 ```
 
-If you have a `CLAUDE.md`, it patches it. `AGENTS.md` for Codex/OpenClaw/OpenCode. `.cursorrules` for Cursor. Your agent starts using Hippo on its next session. For Codex session capture, Hippo wraps the codex launcher only when you explicitly opt in with `hippo hook install codex` (init prints the command when it detects Codex; undo anytime with `hippo hook uninstall codex`).
+If you have a `CLAUDE.md`, it patches it. `AGENTS.md` for Codex/OpenClaw/OpenCode/Pi. `.cursorrules` for Cursor. Your agent starts using Hippo on its next session. For Codex session capture, Hippo wraps the codex launcher only when you explicitly opt in with `hippo hook install codex` (init prints the command when it detects Codex; undo anytime with `hippo hook uninstall codex`).
 
 It also registers the current project in Hippo's workspace registry and installs one machine-level daily runner (6:15am). That runner sweeps every registered workspace, runs `hippo learn --git --days 1`, then `hippo sleep`. You get strict daily consolidation without creating one OS task per project.
 
@@ -628,7 +632,7 @@ hippo watch "npm run build"
 | `hippo dormant [<query>]` | List faded memories sleep kept instead of deleting |
 | `hippo dormant restore <id>` | Bring a dormant memory back to active memory |
 | `hippo dormant forget <id>` | Delete a dormant memory permanently |
-| `hippo doctor [--json]` | Check the install: Node, store, schema, sleep, agent hooks; each problem names its fix |
+| `hippo doctor [--json]` | Check the install: Node, store, schema, sleep, agent hooks; each problem names its fix. It never changes `hippo.db`, though SQLite may leave empty `hippo.db-wal` and `hippo.db-shm` files beside it |
 | `hippo support-bundle [--out <file>] [--include-logs]` | Write a redacted JSON file for a support ticket: versions, doctor checks, config, store counts and log names, never memory text; `--include-logs` adds each log's last 200 lines, which can quote it |
 | `hippo tokens [--days n]` | Estimated tokens of memory text handed to agents, per surface, and what skipping unchanged hook blocks saved |
 | `hippo failures [--days n]` | Failed tool calls the capture-error hook saw, by outcome, and how many errors first happened in another session |
@@ -696,10 +700,11 @@ On `heartbeat`, `block`, `review` and `complete`, a given `--run` is checked aga
 | Framework | Detected by | Patches |
 |-----------|------------|---------|
 | Claude Code | `CLAUDE.md` or `.claude/settings.json` | `CLAUDE.md` + `SessionStart`/`SessionEnd` hooks in `settings.json` |
-| Codex | `AGENTS.md` or `.codex` | `AGENTS.md` + automatic in-place Codex launcher wrapper |
+| Codex | `AGENTS.md` or `.codex` | `AGENTS.md`; session capture is opt-in with `hippo hook install codex`, which wraps the Codex launcher |
 | Cursor | `.cursorrules` or `.cursor/rules` | `.cursorrules` |
 | OpenClaw | `.openclaw` or `AGENTS.md` | native OpenClaw plugin or `AGENTS.md` |
 | OpenCode | `.opencode/` or `opencode.json` | `AGENTS.md` + TS plugin at `~/.config/opencode/plugins/hippo.ts` (subscribes to `session.idle` + `session.created`) |
+| Pi | `.pi` or `.pi/agent` | `AGENTS.md`; copy the [Pi extension](https://github.com/kitfunso/hippo-memory/tree/master/extensions/pi-extension) for session hooks |
 
 No extra commands needed. Just `hippo init` and your agent knows about Hippo.
 
@@ -843,7 +848,7 @@ The AI-memory category matured fast in 2026. Hippo's specific take — bio-decay
 | Lossless compression | No | Yes (AAAK, 30x) | No | No | No | No | No | No | No | No |
 | Cross-tool import (ChatGPT/Claude/Cursor) | Yes | No | No | No | Partial (data sources) | ? | No | Partial (28 data sources) | No (Git ops) | Partial (mRAG: PDFs/images/URLs) |
 | Auto-hook install | Yes | No | No | No | No | No | No | No | No | No |
-| MCP server | Yes | Yes | No | No | Yes (stdio + HTTP/OAuth) | Partial (managed) | Yes (via Letta Code) | Yes (first-party Claude/LangGraph) | Yes | ? |
+| MCP server | Yes | Yes | Yes (hosted, needs an account) | Yes | Yes (stdio + HTTP/OAuth) | Partial (managed) | Yes (via Letta Code) | Yes (first-party Claude/LangGraph) | Yes | ? |
 | Zero runtime deps | Yes | No (ChromaDB) | No | No | No (PGLite or PG+pgvector) | No (managed service) | No (Python deps) | No (Python deps) | Yes (single Rust binary) | No (managed + OSS) |
 | LongMemEval (best published) | 98.0% local / 99.8% voyage R@5 (s_cleaned, per-haystack)\* | 96.6% raw / 100% reranked R@5 | ~49-85% R@5 | N/A | 97.6-97.9% R@5 (s_cleaned\*) | N/A (LoCoMo 80.3%) | N/A | N/A | 88.78% overall accuracy w/ reader\*\* | 83.00% overall\*\* (LoCoMo 93.05%, HaluMem 93.04%) |
 | Git-friendly | Yes | No | No | Yes | Yes | No | No | No | Yes (Git is the model) | ? |
@@ -950,6 +955,54 @@ node run.mjs --adapter all
 
 ---
 
+## FAQ
+
+### How do I give Claude Code memory between sessions?
+
+Run `npm install -g hippo-memory`, then `hippo init` in the project, or `hippo init --scan ~` for every repo on the machine. If the project has a `CLAUDE.md`, init adds a short block telling Claude to run `hippo context --auto` when a session starts. It also adds hooks to Claude Code's settings that keep your pinned memories in context, save a task snapshot before compaction, and run `hippo sleep` when the session ends. The [Claude Code plugin](https://github.com/kitfunso/hippo-memory/tree/master/extensions/claude-code-plugin) is the alternative to these hooks; use one, not both.
+
+### How do I give Cursor memory between sessions?
+
+`hippo init` adds its instructions to `.cursorrules` if the project has one, and the [MCP server](#mcp-server) gives Cursor's agent tools to recall and store memories once you add `hippo mcp` to `.cursor/mcp.json`. `hippo import --cursor .cursorrules` turns your existing rules into memories.
+
+### How do I give Codex memory across sessions?
+
+`hippo init` adds its instructions to your `AGENTS.md`, which Codex reads before it starts work. Capturing Codex sessions is opt-in: `hippo hook install codex` wraps the Codex launcher, and `hippo hook uninstall codex` removes the wrapper.
+
+### Which agents does hippo work with?
+
+`hippo init` detects Claude Code, Codex, Cursor, OpenClaw, OpenCode and Pi, and wires itself into each one's instruction file, hooks or plugin. It only patches instruction files that already exist. Any MCP client can use the [MCP server](#mcp-server), and other tools can call the CLI or the HTTP API that `hippo serve` starts.
+
+### Can I use hippo as an MCP memory server?
+
+Yes. `hippo mcp` runs the server over stdio, and `npx -y hippo-memory mcp` runs it without a global install. Add it to the MCP config of Claude Desktop, Cursor, Windsurf, Cline or any other client (example [above](#mcp-server)); in Claude Code, run `claude mcp add hippo-memory -- hippo mcp`. The agent gets tools such as `hippo_recall`, `hippo_remember` and `hippo_outcome`.
+
+### How is hippo different from mem0?
+
+mem0 uses a language model to extract memories, OpenAI by default in its open-source library, and memories stored through its hosted MCP server live in your Mem0 account ([mem0 docs](https://docs.mem0.ai/platform/mem0-mcp), checked 2026-09-28). Hippo stores memories in SQLite on your machine, needs no account and no model, and `hippo init` wires it into the coding agents it finds. mem0's platform and hippo both mark an older fact superseded when a newer one replaces it. Hippo also lets you mark a recalled memory wrong with `hippo outcome --bad`, and it drops out of the top results.
+
+### Do I still need CLAUDE.md?
+
+Yes, for short standing rules such as build commands, code style and things never to do. Claude Code loads `CLAUDE.md` and its auto memory into every session, and its [memory docs](https://code.claude.com/docs/en/memory) say that when two rules contradict each other, Claude may pick one arbitrarily. Hippo holds the lessons that pile up, recalls the ones that match the task, and retires the ones marked wrong or replaced. `hippo init` adds its block to `CLAUDE.md`, and `hippo import --claude CLAUDE.md` turns existing notes into memories.
+
+### What happens when a memory turns out to be wrong?
+
+Mark it, and it stops coming back. `hippo outcome --bad` weakens the memories from the last recall, `hippo supersede <id> "<new fact>"` replaces one with a newer version, and `hippo reject <id> --reason "<why>"` stops that value from returning at all. On the synthetic E1 test, where every mark is correct, plain BM25 plus the outcome mark cut how often a marked-bad memory stayed in the top five from 71.9% to 0.0%. Real marks are noisier, because `--bad` marks the whole recall batch.
+
+### Where does hippo keep my data?
+
+On your machine, in SQLite: `.hippo/hippo.db` in each project, plus a global store in `~/.hippo/` for lessons shared across projects, with markdown mirrors you can read and commit. Recall makes no network call by default. Text goes to an outside provider only through features that use one: an API embedder, the Jev or LLM reranker, `hippo refine`, and the fact extraction `hippo sleep` runs through Anthropic's API whenever `ANTHROPIC_API_KEY` is set in its environment. To turn that last one off, set `{"extraction":{"enabled":false}}` in `.hippo/config.json`.
+
+### What does hippo cost?
+
+Nothing. Hippo is MIT-licensed and needs no account or API key. Optional features that call an outside provider bill through it: the Jev reranker costs about 0.0004 USD a recall, and API embedders and sleep's fact extraction bill your own keys. Memory text handed to your agent uses context tokens, and `hippo tokens` shows how many.
+
+### Has hippo been shown to make agents better at their work?
+
+Not yet. The published numbers measure retrieval: whether the right memory comes back, and whether a memory marked wrong stays out of the results. The paired test that runs real agent sessions with and without hippo has not had a scored run yet. Every measurement, including failed runs and one retracted claim, is indexed in [docs/evals](https://github.com/kitfunso/hippo-memory/blob/master/docs/evals/README.md).
+
+---
+
 ## Contributing
 
 Issues and PRs welcome. Before contributing, run `hippo status` in the repo root to see the project's own memory.
@@ -963,6 +1016,12 @@ The interesting problems:
 - **MemPalace-style spatial organization.** Could spatial structure (wings/halls/rooms) improve hippo's semantic layer?
 - **AAAK-style compression for semantic memories.** Lossless token compression for context injection.
 
+## Open source and commercial
+
+Hippo is open core, and the line is drawn by who pays. Everything an individual developer or a self-hosted team needs is in this repository under MIT: the CLI, the MCP server, hooks, connectors, the dashboard, tenants, API keys, roles, per-key scope grants, the audit log and zero-touch memory. Code published here stays MIT and stays here.
+
+A commercial edition for larger companies ships as a separate package under a commercial licence from KITFUNSO LTD. It adds SSO (OIDC and SAML sign-in), SCIM, an org admin view, the pilot report and telemetry join, SIEM export of the audit log, offline licence keys, hosted SaaS, and support with an SLA. Pull requests for those features belong there, not here; see [CONTRIBUTING.md](CONTRIBUTING.md).
+
 ## License
 
 MIT

package/dist/secret-detect.d.ts

@@ -38,6 +38,6 @@ export declare function detectSecret(entry: {
  * CS1 pre-compact snapshot fields — can scrub it in place instead.
  */
 export declare function redactSecrets(text: string): string;
-/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer headers and JWTs. */
+/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
 export declare function redactSecretsStrict(text: string): string;
 //# sourceMappingURL=secret-detect.d.ts.map

package/dist/secret-detect.js

@@ -28,6 +28,13 @@ const SECRET_PATTERNS = [
     { name: 'slack-token', re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
     { name: 'stripe-key', re: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b/ },
     { name: 'google-api-key', re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+    // hk_ is hippo's own API key (src/auth.ts); npm, Hugging Face, GitLab and Slack webhook shapes follow gitleaks' rules.
+    { name: 'hippo-api-key', re: /\bhk_[a-z2-7]{24}\.[a-z2-7]{32}\b/ },
+    { name: 'npm-token', re: /\bnpm_[A-Za-z0-9]{36}\b/ },
+    { name: 'huggingface-token', re: /\bhf_[A-Za-z]{34}\b/ },
+    { name: 'gitlab-token', re: /\bglpat-[\w-]{20,}/ },
+    { name: 'google-oauth-token', re: /\bya29\.[\w-]{20,}/ },
+    { name: 'slack-webhook', re: /\bhooks\.slack\.com\/(?:services|workflows|triggers)\/[A-Za-z0-9+/]{43,56}/ },
     { name: 'private-key-block', re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
     // sk-... (OpenAI/Anthropic style) and sk_<vendor>_... shapes. Both require
     // a key-ish noun somewhere in the content (co-occurrence guard) so prose
@@ -51,6 +58,7 @@ const CO_OCCURRENCE_GUARDED = new Set(['sk-style-key', 'sk-underscore-key']);
 // redactSecretsStrict-only: too noisy for whole-entry memory scanning, worth hiding once text leaves the machine.
 const STRICT_ONLY_PATTERNS = [
     /\bbearer\s+[A-Za-z0-9._~+/-]{16,}=*/gi,
+    /\bauthorization["']?\s*[:=]\s*["']?basic\s+[A-Za-z0-9+/]{8,}={0,2}/gi,
     /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*/g,
 ];
 /**
@@ -82,7 +90,7 @@ export function detectSecret(entry) {
 export function redactSecrets(text) {
     return redactText(text, false);
 }
-/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer headers and JWTs. */
+/** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
 export function redactSecretsStrict(text) {
     return redactText(text, true);
 }

package/dist/support-bundle.js

@@ -1,7 +1,8 @@
-/** `hippo support-bundle`: one redacted JSON snapshot for a support ticket. Read-only; never touches memory content. */
+/** `hippo support-bundle`: one redacted JSON snapshot for a support ticket. Read-only (SQLite may leave empty -wal and -shm files); never touches memory content. */
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { pathToFileURL } from 'url';
 import { findHippoStoreDir, isGlobalStoreRoot, realpathOrResolve } from './project-identity.js';
 import { getGlobalRoot } from './shared.js';
 import { isInitialized } from './store.js';
@@ -189,18 +190,11 @@ function nativeRealPathKey(p) {
         return null;
     }
 }
-// Longest first: where one home form nests in another (a test home under the real one), swap the longer.
-function collectHomeForms(home, probes) {
-    const forms = new Set();
-    const add = (s) => { if (s.length >= 3)
-        forms.add(s); };
+function collectHomeAliases(home, probes) {
+    const aliases = new Set();
     for (const base of [home, realpathOrResolve(home), os.homedir(), realpathOrResolve(os.homedir())]) {
-        add(base);
-        add(path.resolve(base));
-        if (process.platform === 'win32') {
-            add(base.replace(/\\/g, '/'));
-            add(path.resolve(base).replace(/\\/g, '/'));
-        }
+        aliases.add(base);
+        aliases.add(path.resolve(base));
     }
     // The alias (e.g. a short-name temp root) can sit above the probe itself, so walk ancestors and
     // compare native realpaths rather than checking each probe alone.
@@ -209,34 +203,56 @@ function collectHomeForms(home, probes) {
         let dir = path.resolve(probe);
         for (;;) {
             const key = nativeRealPathKey(dir);
-            if (key !== null && homeKeys.has(key)) {
-                add(dir);
-                if (process.platform === 'win32')
-                    add(dir.replace(/\\/g, '/'));
-            }
+            if (key !== null && homeKeys.has(key))
+                aliases.add(dir);
             const parent = path.dirname(dir);
             if (parent === dir)
                 break;
             dir = parent;
         }
     }
-    const seen = new Set();
-    const deduped = [];
-    for (const f of [...forms].sort((a, b) => b.length - a.length)) {
-        const key = process.platform === 'win32' ? f.toLowerCase() : f;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        deduped.push(f);
-    }
-    return deduped;
+    return aliases;
+}
+// Node's own encoding, so it matches file URLs and ESM stack frames; a drive path's URL gains a leading slash.
+function fileUrlPath(p) {
+    const pathname = pathToFileURL(p).pathname;
+    return /^\/[A-Za-z]:/.test(pathname) ? pathname.slice(1) : pathname;
+}
+// A home turns up as a path, as a file URL's percent-encoded path, and as a Claude Code project folder name.
+const HOME_SPELLINGS = [
+    (p) => p,
+    fileUrlPath,
+    (p) => p.replace(/[^A-Za-z0-9]/g, '-'),
+];
+// A Windows separator can be written \, / or JSON-escaped (\\ in a log line quoting JSON), so any of them matches.
+function spellingPattern(spelling) {
+    if (process.platform !== 'win32')
+        return escapeRegExp(spelling);
+    return spelling.split(/[\\/]+/).map(escapeRegExp).join('(?:\\\\+|/)');
 }
-function replaceHomeForms(text, forms) {
-    if (forms.length === 0)
-        return text;
-    // Stop only before another name character: "<home> now" and "<home>." swap, a longer user name ("<home>ty") does not.
-    const re = new RegExp(`(?:${forms.map(escapeRegExp).join('|')})(?![\\p{L}\\p{N}_])`, process.platform === 'win32' ? 'giu' : 'gu');
-    return text.replace(re, '~');
+/** One pattern for every alias of the home in every spelling, or null when none is long enough to swap safely. */
+function buildHomePattern(home, probes) {
+    const spellings = new Set();
+    for (const alias of collectHomeAliases(home, probes)) {
+        for (const spell of HOME_SPELLINGS) {
+            const s = spell(alias);
+            if (s.length >= 3)
+                spellings.add(s);
+        }
+    }
+    // Longest first: where one home nests in another (a test home under the real one), swap the longer.
+    const patterns = new Map();
+    for (const s of [...spellings].sort((a, b) => b.length - a.length)) {
+        const pattern = spellingPattern(s);
+        const key = process.platform === 'win32' ? pattern.toLowerCase() : pattern;
+        if (!patterns.has(key))
+            patterns.set(key, pattern);
+    }
+    if (patterns.size === 0)
+        return null;
+    // Whole names only: "<home> now" and "<home>." swap; "<home>ty", or "web-app" for a home of /app, do not.
+    const alternatives = [...patterns.values()].join('|');
+    return new RegExp(`(?<![\\p{L}\\p{N}_])(?:${alternatives})(?![\\p{L}\\p{N}_])`, process.platform === 'win32' ? 'giu' : 'gu');
 }
 const URL_RE = /\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi;
 function redactUrlsInString(text) {
@@ -255,37 +271,40 @@ function redactUrlsInString(text) {
         }
     });
 }
-function redactString(text, homeForms) {
-    return replaceHomeForms(redactSecretsStrict(redactUrlsInString(text)), homeForms);
+function redactString(text, homePattern) {
+    const scrubbed = redactSecretsStrict(redactUrlsInString(text));
+    return homePattern === null ? scrubbed : scrubbed.replace(homePattern, '~');
 }
-function redactStrings(value, homeForms) {
+function redactStrings(value, homePattern) {
     if (isJsonString(value))
-        return redactString(value, homeForms);
+        return redactString(value, homePattern);
     if (Array.isArray(value))
-        return value.map((v) => redactStrings(v, homeForms));
+        return value.map((v) => redactStrings(v, homePattern));
     if (isJsonObject(value)) {
         const out = {};
         for (const [k, v] of Object.entries(value))
-            out[k] = redactStrings(v, homeForms);
+            out[k] = redactStrings(v, homePattern);
         return out;
     }
     return value;
 }
 /** Read-only: builds one redacted support-ticket snapshot. Never reads a memory content column. */
 export function buildSupportBundle(opts) {
+    // Before doctor: its read-only open leaves an empty -wal that the store's file list would then report.
+    const stores = buildStores(opts);
     const bundle = {
         format: 'hippo-support-bundle/1',
         createdAt: opts.now.toISOString(),
         hippo: opts.version,
         runtime: buildRuntime(),
         doctor: JSON.parse(JSON.stringify(runDoctor(opts))),
-        stores: buildStores(opts),
+        stores,
         env: listSetEnvNames(),
         logs: buildLogsSection(opts),
     };
     // Store paths found from the working folder arrive resolved; the global root arrives as HIPPO_HOME was typed, and log lines
     // often quote the temp folder, which usually sits under the home.
-    const redacted = redactStrings(bundle, collectHomeForms(opts.home, [getGlobalRoot(), os.tmpdir()]));
+    const redacted = redactStrings(bundle, buildHomePattern(opts.home, [getGlobalRoot(), os.tmpdir()]));
     // SAFETY: the value built above is always a JsonObject; redactStrings preserves object shape.
     return redacted;
 }

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.52.2";
+export declare const PACKAGE_VERSION = "1.52.4";
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export declare function compareSemver(a: string, b: string): number;
 //# sourceMappingURL=version.d.ts.map

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.52.2';
+export const PACKAGE_VERSION = '1.52.4';
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export function compareSemver(a, b) {
     const parse = (v) => {

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

@@ -1,8 +1,8 @@
 {
   "id": "hippo-memory",
   "name": "Hippo Memory",
-  "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.52.2",
+  "description": "Memory for AI agents that learns what is wrong and stops repeating it. Injects context at session start and captures errors.",
+  "version": "1.52.4",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.52.2",
+  "version": "1.52.4",
   "type": "module",
   "description": "Hippo Memory plugin for OpenClaw - biologically-inspired agent memory",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "hippo-memory",
   "name": "Hippo Memory",
-  "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.52.2",
+  "description": "Memory for AI agents that learns what is wrong and stops repeating it. Injects context at session start and captures errors.",
+  "version": "1.52.4",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hippo-memory",
-  "version": "1.52.2",
-  "description": "Biologically-inspired memory for AI agents. Zero runtime deps, SQLite, MCP server, and an opt-in hosted TypeSafe Jev reranker. Decay, retrieval strengthening, consolidation.",
+  "version": "1.52.4",
+  "description": "Memory for AI agents that learns what is wrong and stops repeating it. MCP server and hooks for Claude Code, Codex and Cursor. SQLite, zero runtime deps.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",
   "main": "./dist/index.js",
@@ -46,26 +46,34 @@
   },
   "keywords": [
     "memory",
-    "ai",
-    "agents",
-    "llm",
-    "claude",
-    "context",
-    "recall",
-    "episodic",
-    "semantic",
-    "embeddings",
-    "hybrid-search",
     "agent-memory",
+    "ai-memory",
+    "llm-memory",
     "long-term-memory",
+    "persistent-memory",
+    "memory-layer",
     "mcp",
+    "mcp-server",
     "model-context-protocol",
     "claude-code",
+    "claude",
+    "codex",
+    "cursor",
+    "openclaw",
+    "opencode",
+    "ai-agents",
+    "coding-agent",
+    "agents",
+    "llm",
     "rag",
     "retrieval",
+    "hybrid-search",
+    "embeddings",
     "sqlite",
+    "local-first",
     "cli",
-    "typescript"
+    "context",
+    "recall"
   ],
   "author": "Keith",
   "license": "MIT",