hippo-memory 1.64.0 → 1.65.0

package/dist/server.js

@@ -2,8 +2,9 @@ import { envPort, envRequireAuth, envV1Rps } from './env.js';
 import { createServer } from 'node:http';
 import { existsSync } from 'node:fs';
 import { detectServer, removePidfileIfOwned, writePidfile } from './server-detect.js';
-import { closeHippoDb, getHippoDbPath, isStoreBusy, openHippoDb, SERVER_DB_WAIT_MS, withBusyWait, withSqliteBlocked } from './db.js';
+import { closeHippoDb, getHippoDbPath, isStoreBusy, openHippoDb, outsideRequestStores, runWithRequestStores, SERVER_DB_WAIT_MS, withSqliteBlocked } from './db.js';
 import { sqliteStore } from './store-port.js';
+import { markSharedStore } from './config.js';
 import { auditWriteFailureCount } from './audit.js';
 import { PACKAGE_VERSION } from './version.js';
 import { errorFields, log } from './log.js';
@@ -11,7 +12,7 @@ import { createRateLimiter } from './rate-limit.js';
 import { authCreateSelf, authRevoke, RecallContractError } from './api.js';
 import { handleSlackEventsWebhook } from './connectors/slack/webhook.js';
 import { handleGitHubEventsWebhook } from './connectors/github/webhook.js';
-import { BodyTimeoutError, BodyTooLargeError, closeAfterReply, HttpError, JSON_HEADERS, sendJson } from './http-util.js';
+import { BodyTimeoutError, BodyTooLargeError, closeAfterReply, HttpError, JSON_HEADERS, sendJson, STORE_NOT_PORTED_MESSAGE } from './http-util.js';
 import { ForbiddenError } from './api-errors.js';
 import { buildContextWithAuth, isLoopback, LIMITER_MAX_KEYS, requireAuth } from './server/auth.js';
 import { enforceRateLimit } from './server/client-ip.js';
@@ -92,7 +93,7 @@ const LOOPBACK_HOSTS = new Set(['127.0.0.1', '::1', 'localhost']);
 const V1_ROUTES = [
     { method: 'POST', path: '/v1/memories', handler: handleCreateMemory },
     { method: 'GET', path: '/v1/graph', handler: handleGetGraph },
-    { method: 'GET', path: '/v1/memories', handler: handleRecallMemories },
+    { method: 'GET', path: '/v1/memories', storeReady: true, handler: handleRecallMemories },
     { method: 'GET', pattern: '/v1/sessions/:id/assemble', handler: handleAssembleSession },
     { method: 'GET', pattern: '/v1/recall/drill/:id', handler: handleDrillRecall },
     { method: 'POST', pattern: '/v1/memories/:id/archive', handler: handleArchiveMemory },
@@ -238,10 +239,9 @@ function dispatchPublicJson({ res, opts }, method, path) {
     res.end(text);
     return true;
 }
-const NOT_ON_STORE_MESSAGE = 'not available on this store';
 function assertSqliteStore(opts) {
     if (opts.store.kind !== 'sqlite')
-        throw new HttpError(501, NOT_ON_STORE_MESSAGE);
+        throw new HttpError(501, STORE_NOT_PORTED_MESSAGE);
 }
 /** Under another store, a route not yet ported answers 501 without running; the caller is checked first, so a bad key is still a 401. */
 async function refuseUnportedRoute(req, opts) {
@@ -264,12 +264,25 @@ async function handleRequest(req, res, opts, startedAt, streamSlots, limiter) {
     }
     enforceRateLimit(req, path, limiter);
     const routeRequest = { req, res, opts, query };
-    if (await dispatchV1Route(routeRequest, method, path))
+    if (await runWithRequestStores(() => dispatchScopedRoute(routeRequest, method, path), { busyWaitMs: SERVER_DB_WAIT_MS }))
         return;
-    if (dispatchPublicJson(routeRequest, method, path))
-        return;
-    if (await dispatchAddonRoute(routeRequest, method, path))
+    // Outside the request scope: the heartbeat timer outlives the request. Store-ready: the stream only authenticates, through the port.
+    if (method === 'GET' && path === '/mcp/stream') {
+        await handleMcpStream(req, res, opts, streamSlots);
         return;
+    }
+    res.writeHead(404, JSON_HEADERS);
+    res.end(JSON.stringify({ error: 'not found' }));
+}
+/** Every route that runs inside a request scope, so it opens each store once: the /v1 table, public JSON, add-on routes, the webhooks and POST /mcp. */
+async function dispatchScopedRoute(r, method, path) {
+    if (await dispatchV1Route(r, method, path))
+        return true;
+    if (dispatchPublicJson(r, method, path))
+        return true;
+    if (await dispatchAddonRoute(r, method, path))
+        return true;
+    const { req, res, opts } = r;
     if (method === 'POST' && path === '/v1/connectors/slack/events') {
         // Bearer auth deliberately skipped: this route is in PUBLIC_ROUTES and authenticates via the Slack HMAC signature.
         if (!isPublicRoute(method, path)) {
@@ -278,7 +291,7 @@ async function handleRequest(req, res, opts, startedAt, streamSlots, limiter) {
         }
         assertSqliteStore(opts);
         await handleSlackEventsWebhook({ req, res, opts });
-        return;
+        return true;
     }
     if (method === 'POST' && path === '/v1/connectors/github/events') {
         if (!isPublicRoute(method, path)) {
@@ -286,20 +299,14 @@ async function handleRequest(req, res, opts, startedAt, streamSlots, limiter) {
         }
         assertSqliteStore(opts);
         await handleGitHubEventsWebhook({ req, res, opts });
-        return;
+        return true;
     }
+    // Store-ready: under another store the MCP layer lists and runs only the tools ported to the port.
     if (method === 'POST' && path === '/mcp') {
-        await refuseUnportedRoute(req, opts);
         await handleMcpPost(req, res, opts);
-        return;
-    }
-    // Store-ready: the stream and its heartbeat only authenticate, and auth goes through the port.
-    if (method === 'GET' && path === '/mcp/stream') {
-        await handleMcpStream(req, res, opts, streamSlots);
-        return;
+        return true;
     }
-    res.writeHead(404, JSON_HEADERS);
-    res.end(JSON.stringify({ error: 'not found' }));
+    return false;
 }
 function sendHealth(req, res, startedAt) {
     // Loopback callers (detectServer's stale-pidfile probe reads version and
@@ -387,7 +394,8 @@ function createStoreHolder(hippoRoot, store) {
         if (heldDb || stopHolding || !existsSync(getHippoDbPath(hippoRoot)))
             return;
         try {
-            heldDb = openHippoDb(hippoRoot);
+            // The 'finish' listener can fire inside a request scope, which would close this connection with the request.
+            heldDb = outsideRequestStores(() => openHippoDb(hippoRoot));
         }
         catch (err) {
             stopHolding = true;
@@ -522,6 +530,9 @@ export async function serve(opts) {
         ...opts, routes, publicJsonBodies, store: opts.store ?? sqliteStore(opts.hippoRoot), callerLimiter, failedAuthLimiter,
     };
     const { kind } = served.store;
+    // A store other than hippo.db is a team's central server, so its folder's config.json must not decide shared-ness.
+    if (kind !== 'sqlite')
+        markSharedStore(opts.hippoRoot);
     const holder = createStoreHolder(opts.hippoRoot, served.store);
     const inflight = new Set();
     const server = createServer((req, res) => {
@@ -531,7 +542,7 @@ export async function serve(opts) {
         const requestId = resolveRequestId(req.headers['x-request-id']);
         requestIds.set(req, requestId);
         res.setHeader('X-Request-Id', requestId);
-        const run = () => withBusyWait(SERVER_DB_WAIT_MS, () => handleRequest(req, res, served, startedAt, streamSlots, limiter));
+        const run = () => handleRequest(req, res, served, startedAt, streamSlots, limiter);
         // A missed port under another store would otherwise create and write a hippo.db that store never reads.
         (kind === 'sqlite' ? run() : withSqliteBlocked(kind, run)).catch((err) => replyOrClose(req, res, err, requestId));
     });

package/dist/store/entry-writes.d.ts

@@ -36,6 +36,8 @@ export interface StrengthenOptions {
 /** Strengthen what a read returned: update only the four retrieval columns on the live row, never a stale copy.
  *  Best effort: a failure logs and never fails the read. Returns the ids found in this store. */
 export declare function strengthenRetrieved(hippoRoot: string, ids: readonly string[], opts: StrengthenOptions): Set<string>;
+/** strengthenRetrieved on an open handle that holds no transaction, so a recall's last writes share one handle. */
+export declare function strengthenRetrievedInOwnTx(db: DatabaseSyncLike, ids: readonly string[], opts: StrengthenOptions): Set<string>;
 /** strengthenRetrieved on the caller's handle, inside the caller's transaction. Throws; the caller decides. */
 export declare function strengthenRetrievedOn(db: DatabaseSyncLike, ids: readonly string[], opts: StrengthenOptions): Set<string>;
 /** Rewrites a live row's tags and its full-text row on the caller's transaction, with no audit row. */

package/dist/store/entry-writes.js

@@ -1,5 +1,5 @@
 import { markRetrieved } from '../memory.js';
-import { closeHippoDb, openHippoDb, withWriteScope } from '../db.js';
+import { closeHippoDb, openHippoDb, rethrowIfSqliteBlocked, withWriteScope } from '../db.js';
 import { RejectedValueError } from '../rejection.js';
 import { markSummaryDirtyInTx } from '../summary-dirty.js';
 import { log } from '../log.js';
@@ -73,30 +73,38 @@ export function writeEntryMirrors(hippoRoot, entry) {
 /** Strengthen what a read returned: update only the four retrieval columns on the live row, never a stale copy.
  *  Best effort: a failure logs and never fails the read. Returns the ids found in this store. */
 export function strengthenRetrieved(hippoRoot, ids, opts) {
-    const found = new Set();
     if (ids.length === 0 || opts.recallBoostAblated)
-        return found;
+        return new Set();
     let db;
     try {
         db = openHippoDb(hippoRoot);
-        db.exec('BEGIN IMMEDIATE');
-        for (const id of strengthenRetrievedOn(db, ids, opts))
-            found.add(id);
-        db.exec('COMMIT');
     }
     catch (error) {
-        try {
-            db?.exec('ROLLBACK');
-        }
-        catch { /* already rolled back; keep the original error */ }
-        log.warn(`retrieval stats not saved (${error instanceof Error ? error.message : String(error)})`);
-        found.clear();
+        rethrowIfSqliteBlocked(error);
+        warnStrengthenFailed(error);
+        return new Set();
+    }
+    try {
+        return strengthenRetrievedInOwnTx(db, ids, opts);
     }
     finally {
-        if (db)
-            closeHippoDb(db);
+        closeHippoDb(db);
     }
-    return found;
+}
+/** strengthenRetrieved on an open handle that holds no transaction, so a recall's last writes share one handle. */
+export function strengthenRetrievedInOwnTx(db, ids, opts) {
+    if (ids.length === 0 || opts.recallBoostAblated)
+        return new Set();
+    try {
+        return withWriteScope(db, 'strengthen_retrieved', () => strengthenRetrievedOn(db, ids, opts));
+    }
+    catch (error) {
+        warnStrengthenFailed(error);
+        return new Set();
+    }
+}
+function warnStrengthenFailed(error) {
+    log.warn(`retrieval stats not saved (${error instanceof Error ? error.message : String(error)})`);
 }
 /** strengthenRetrieved on the caller's handle, inside the caller's transaction. Throws; the caller decides. */
 export function strengthenRetrievedOn(db, ids, opts) {

package/dist/store-port.d.ts

@@ -1,13 +1,82 @@
 import { type ApiKeyRecord } from './auth.js';
+import { type AppendAuditOpts } from './audit.js';
+import type { ContinuityBlock } from './api/recall-types.js';
+import { type ActiveGoals, type GetActiveGoalsOpts, type GoalRecallLogRow } from './goals.js';
+import type { MemoryEntry } from './memory.js';
+import { type PlanningFallacyEvidence } from './predictions/planning-fallacy.js';
+import { type RecallTraceInput } from './recall-trace.js';
+import { type StrengthenOptions } from './store/entry-writes.js';
+import { type OriginFilter } from './store/search-rows.js';
+import { type ContinuityKey } from './store/sessions.js';
+import { type TokenUse } from './token-ledger.js';
+/** The arguments of `loadRecallSearchEntries` after the query, by name. */
+export interface RecallSearchArgs {
+    readonly limit: number;
+    readonly tenantId?: string;
+    readonly requestedScope?: string;
+    readonly explicitScopeMode: 'exact' | 'additive';
+    readonly includeSuperseded: boolean;
+    readonly originProjects?: OriginFilter;
+    /** The caller's personal scope, which the default deny admits; undefined admits no personal row. */
+    readonly ownScope: string | undefined;
+}
+/** Everything one recall writes once its reply is decided, so a store writes it on one connection. */
+export interface RecallWrites {
+    /** Insert or ignore on (memory_id, goal_id), so the first row wins, a duplicate inside this batch included. First drop a row
+     *  whose memory_id is in no memories row of this store, whatever that row's tenant, as `localGoalRecallRows` does. */
+    readonly goalLog: readonly GoalRecallLogRow[];
+    /** In the order they happened. */
+    readonly audit: readonly AppendAuditOpts[];
+    readonly trace?: RecallTraceInput;
+    /** Nothing when `recallBoostAblated`. Each id found, in `tenantId` when set, gets the retrieval_count, last_retrieved,
+     *  half_life_days and strength `markRetrieved` computes from the row read before any update, so a repeated id moves once. */
+    readonly strengthen?: {
+        readonly ids: readonly string[];
+        readonly opts: StrengthenOptions;
+    };
+}
 /** What `serve()` reads and writes through. Each method is atomic and no transaction spans an await, since SQLite's lock wait blocks the event loop; a lock timeout throws `StoreBusyError`. */
 export interface HippoStore {
     /** 'sqlite' is hippo.db under the served root. Under any other kind, an unported route answers 501 and a hippo.db open inside a request throws. */
     readonly kind: string;
     /** The api_keys row for `keyId` with its scope grants, revoked or not; null when no row matches. */
     findApiKey(keyId: string): Promise<ApiKeyRecord | null>;
+    /** Recall candidates in `loadRecallSearchEntries` order: FTS, then LIKE, then every row in scope. */
+    searchRecallEntries(query: string, args: RecallSearchArgs): Promise<MemoryEntry[]>;
+    /** The rows among the first 500 ids, a tenant narrowing them, ordered by created, then content, then id, all ascending,
+     *  as `loadEntriesByIds` does; the input order is ignored. */
+    entriesByIds(ids: readonly string[], tenantId?: string): Promise<MemoryEntry[]>;
+    /** The session's active goals and their policies, read together so a goal and its policy never disagree. */
+    activeGoals(opts: GetActiveGoalsOpts): Promise<ActiveGoals>;
+    /** The first `count` (at most 200) unsuperseded raw rows a tenant, a non-empty session id and non-null `origins` (those projects and
+     *  user-global rows) must narrow, by created descending, then content and id ascending, as `loadFreshRawMemories` does. */
+    freshRawEntries(count: number, tenantId: string | undefined, sessionId: string | undefined, origins: readonly string[] | null): Promise<MemoryEntry[]>;
+    /** The newest active snapshot a non-null `key` must narrow to one owner and project (null only on an unshared hippo.db), then for its session
+     *  the newest handoff (same key) and `eventLimit` newest events returned oldest first, each tie broken by the larger id; the caller applies scope. */
+    continuity(tenantId: string, eventLimit: number, key: ContinuityKey | null): Promise<ContinuityBlock>;
+    /** Resolves a forward claim's tokens to one class and reads its baserate, writing no audit row. */
+    planningFallacyEvidence(tenantId: string, classQueryTokens: readonly string[]): Promise<PlanningFallacyEvidence>;
+    /** Appends the rows in order, all or none. */
+    appendAuditEvents(events: readonly AppendAuditOpts[]): Promise<void>;
+    /** Writes the goal log and audit rows in one transaction and rejects with none written if it fails. Then the trace and
+     *  the strengthen, each on its own: a failure there logs and still resolves, since the reply is already decided. */
+    finishRecall(writes: RecallWrites): Promise<void>;
+    /** Adds `recalled` to the one store-wide total_recalled counter, no tenant; the SQLite store also rewrites stats.json. */
+    bumpRecallStats(recalled: number): Promise<void>;
+    /** One token-ledger row. Throws, so the caller decides whether a ledger failure matters. */
+    recordTokens(use: TokenUse): Promise<void>;
     /** Releases the store's connections; `serve()` closes only a store it made itself. */
     close(): Promise<void>;
 }
-/** The built-in store: today's synchronous hippo.db functions behind the port, one handle per call, so close has nothing to release. */
+/** The store a request runs on: the served one, else hippo.db under its root, as the CLI and SDK callers have it. */
+export declare function storeFor(ctx: {
+    readonly hippoRoot: string;
+    readonly store?: HippoStore;
+}): HippoStore;
+/** The built-in store: today's synchronous hippo.db functions behind the port, each call on its own short-lived handles, so close has nothing to release. */
 export declare function sqliteStore(hippoRoot: string): HippoStore;
+/** sqliteStore's continuity read, for the synchronous recall that cannot await the port. */
+export declare function continuityAt(hippoRoot: string, tenantId: string, eventLimit: number, key: ContinuityKey | null): ContinuityBlock;
+/** sqliteStore's finishRecall, for the synchronous recall that cannot await the port. */
+export declare function finishRecallAt(hippoRoot: string, writes: RecallWrites): void;
 //# sourceMappingURL=store-port.d.ts.map

package/dist/store-port.js

@@ -1,20 +1,98 @@
 // The async seam the server reaches its store through, so an add-on can serve from a database other than hippo.db.
 import { readApiKeyRecord } from './auth.js';
-import { closeHippoDb, openHippoDb } from './db.js';
-/** The built-in store: today's synchronous hippo.db functions behind the port, one handle per call, so close has nothing to release. */
+import { appendAuditEvent } from './audit.js';
+import { closeHippoDb, openHippoDb, withWriteScope } from './db.js';
+import { activeGoalsWithPolicies, localGoalRecallRows, writeGoalRecallLog, } from './goals.js';
+import { planningFallacyEvidenceAt } from './predictions/planning-fallacy.js';
+import { writeRecallTrace } from './recall-trace.js';
+import { loadEntriesByIds, loadFreshRawMemories } from './store/entry-reads.js';
+import { strengthenRetrievedInOwnTx } from './store/entry-writes.js';
+import { loadLatestHandoff } from './store/handoffs.js';
+import { updateStats } from './store/index-and-stats.js';
+import { loadRecallSearchEntries } from './store/search-rows.js';
+import { listSessionEvents, loadActiveTaskSnapshot } from './store/sessions.js';
+import { recordTokenUse } from './token-ledger.js';
+function onHandle(hippoRoot, fn) {
+    const db = openHippoDb(hippoRoot);
+    try {
+        return fn(db);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/** The store a request runs on: the served one, else hippo.db under its root, as the CLI and SDK callers have it. */
+export function storeFor(ctx) {
+    return ctx.store ?? sqliteStore(ctx.hippoRoot);
+}
+/** The built-in store: today's synchronous hippo.db functions behind the port, each call on its own short-lived handles, so close has nothing to release. */
 export function sqliteStore(hippoRoot) {
     return {
         kind: 'sqlite',
         async findApiKey(keyId) {
-            const db = openHippoDb(hippoRoot);
-            try {
-                return readApiKeyRecord(db, keyId);
-            }
-            finally {
-                closeHippoDb(db);
-            }
+            return onHandle(hippoRoot, (db) => readApiKeyRecord(db, keyId));
+        },
+        async searchRecallEntries(query, args) {
+            return loadRecallSearchEntries(hippoRoot, query, args.limit, args.tenantId, args.requestedScope, args.explicitScopeMode, args.includeSuperseded, args.originProjects, args.ownScope);
+        },
+        async entriesByIds(ids, tenantId) {
+            return loadEntriesByIds(hippoRoot, ids, tenantId);
+        },
+        async activeGoals(opts) {
+            return activeGoalsWithPolicies(hippoRoot, opts);
+        },
+        async freshRawEntries(count, tenantId, sessionId, origins) {
+            return loadFreshRawMemories(hippoRoot, count, tenantId, sessionId, origins ?? undefined);
+        },
+        async continuity(tenantId, eventLimit, key) {
+            return continuityAt(hippoRoot, tenantId, eventLimit, key);
+        },
+        async planningFallacyEvidence(tenantId, classQueryTokens) {
+            return planningFallacyEvidenceAt(hippoRoot, tenantId, classQueryTokens);
+        },
+        async appendAuditEvents(events) {
+            if (events.length === 0)
+                return;
+            onHandle(hippoRoot, (db) => withWriteScope(db, 'append_audit_events', () => {
+                for (const event of events)
+                    appendAuditEvent(db, event);
+            }));
+        },
+        async finishRecall(writes) {
+            finishRecallAt(hippoRoot, writes);
+        },
+        async bumpRecallStats(recalled) {
+            updateStats(hippoRoot, { recalled });
+        },
+        async recordTokens(use) {
+            onHandle(hippoRoot, (db) => recordTokenUse(db, use));
         },
         async close() { },
     };
 }
+/** sqliteStore's continuity read, for the synchronous recall that cannot await the port. */
+export function continuityAt(hippoRoot, tenantId, eventLimit, key) {
+    const activeSnapshot = loadActiveTaskSnapshot(hippoRoot, tenantId, key ?? undefined);
+    const sessionId = activeSnapshot?.session_id ?? undefined;
+    return {
+        activeSnapshot,
+        sessionHandoff: sessionId ? loadLatestHandoff(hippoRoot, tenantId, sessionId, {}, key ?? undefined) : null,
+        recentSessionEvents: sessionId ? listSessionEvents(hippoRoot, tenantId, { session_id: sessionId, limit: eventLimit }) : [],
+    };
+}
+/** sqliteStore's finishRecall, for the synchronous recall that cannot await the port. */
+export function finishRecallAt(hippoRoot, writes) {
+    onHandle(hippoRoot, (db) => {
+        withWriteScope(db, 'finish_recall', () => {
+            writeGoalRecallLog(db, localGoalRecallRows(db, writes.goalLog));
+            for (const event of writes.audit)
+                appendAuditEvent(db, event);
+        });
+        // Each opens its own transaction, so neither can share the scope above.
+        if (writes.trace)
+            writeRecallTrace(db, writes.trace);
+        if (writes.strengthen)
+            strengthenRetrievedInOwnTx(db, writes.strengthen.ids, writes.strengthen.opts);
+    });
+}
 //# sourceMappingURL=store-port.js.map

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.65.0";
 /** 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.65.0';
 /** 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.65.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.64.0",
+  "version": "1.65.0",
   "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.65.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.64.0",
+  "version": "1.65.0",
   "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",