hippo-memory 1.52.9 → 1.53.1

package/dist/store.d.ts

@@ -289,6 +289,8 @@ export declare function loadEntriesByIds(hippoRoot: string, ids: readonly string
 /** 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[], tenantId?: string): 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[], tenantId?: string): Set<string>;
 /**
  * All `kind='raw'` rows for a given session, tenant-scoped, returned
  * oldest-first. Used by `api.assemble` to walk a session's chronological
@@ -350,6 +352,10 @@ export declare function loadFreshRawMemories(hippoRoot: string, count: number, t
  * Used by `drillDown` (Task 3).
  */
 export declare function loadChildrenOf(hippoRoot: string, parentId: string, tenantId?: string): MemoryEntry[];
+/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL); tests/dormant-memories.test.ts pins it to the schema. */
+export declare const MEMORY_BACKED_TABLES: readonly ["predictions", "decisions", "incidents", "processes", "policies", "skills", "project_briefs", "customer_notes"];
+/** Ids of memories that back a first-class object, for passes that plan deletes before making them. A table missing from an older schema is skipped. */
+export declare function memoriesBackingObjects(hippoRoot: string): Set<string>;
 /**
  * AT1 (plan §4, round-2 fix, designed from source): db-scoped delete core.
  * `deleteEntry` used to open+close its OWN connection, which meant it could
@@ -367,7 +373,7 @@ export declare function loadChildrenOf(hippoRoot: string, parentId: string, tena
  * Default keeps `deleteEntry` byte-identical to its pre-split behavior.
  *
  * Returns `{tenantId, dagParentId}` for the removed row, or `null` if no row with `id`
- * existed or `automatic` refused it (pinned or raw at DELETE time, so a late pin wins).
+ * existed or `automatic` refused it (pinned, raw, kept for good or backing an object at DELETE time, so a late pin wins).
  */
 export declare function deleteEntryCore(db: ReturnType<typeof openHippoDb>, id: string, opts?: {
     actor?: string;
@@ -400,7 +406,7 @@ export declare function deleteEntry(hippoRoot: string, id: string, opts?: {
  *  `dormant` (src/dormant.ts): each move's snapshot is inserted into `dormant_memories` and its `memories` row
  *  leaves exactly like a delete (FTS row, DAG parent dirty-mark, mirrors), in the same transaction, so a memory
  *  is never in both places or in neither. Deletes and moves both skip rows that are no longer auto-deletable
- *  (pinned or raw since the caller decided). Returns the ids that left `memories`, deleted or moved. */
+ *  (pinned, raw, kept for good or backing an object since the caller decided). Returns the ids that left `memories`, deleted or moved. */
 export declare function batchWriteAndDelete(hippoRoot: string, toWrite: MemoryEntry[], toDeleteIds: string[], opts?: {
     snapshot?: ReadonlyMap<string, MemoryEntry>;
     dormant?: DormantMove[];
@@ -415,6 +421,12 @@ export declare function batchWriteAndDelete(hippoRoot: string, toWrite: MemoryEn
 export declare function loadAllEntries(hippoRoot: string, tenantId?: string): MemoryEntry[];
 /** Every memory row on an open connection, so a caller can read inside its own transaction. */
 export declare function selectAllEntries(db: DatabaseSyncLike, tenantId?: string): MemoryEntry[];
+/** Live rows whose source starts with `prefix`, on the caller's handle; LIKE folds case, so the prefix is checked again exactly. */
+export declare function selectLiveEntriesBySourcePrefix(db: DatabaseSyncLike, tenantId: string, prefix: string): MemoryEntry[];
+/** Rewrites a live row's tags and its full-text row on the caller's transaction, with no audit row. */
+export declare function setEntryTagsInTx(db: DatabaseSyncLike, entry: MemoryEntry): void;
+/** Removes a row from `memories` and full-text search on the caller's transaction, as sleep's dormant move does, and marks its summary parent dirty. */
+export declare function deleteEntryRowInTx(db: DatabaseSyncLike, entry: MemoryEntry, actor: string): void;
 export declare function loadContentsWithTag(hippoRoot: string, tenantId: string, tag: string): string[];
 export interface AmbientRecallRequest {
     terms: string[];

package/dist/store.js

@@ -1349,20 +1349,8 @@ export function strengthenRetrieved(hippoRoot, ids, tenantId) {
     try {
         db = openHippoDb(hippoRoot);
         db.exec('BEGIN IMMEDIATE');
-        const tenantClause = tenantId !== undefined ? ' AND tenant_id = ?' : '';
-        const select = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id = ?${tenantClause}`);
-        const live = [];
-        for (const id of ids) {
-            // SAFETY: the SELECT names exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
-            const row = (tenantId !== undefined ? select.get(id, tenantId) : select.get(id));
-            if (row)
-                live.push(rowToEntry(row));
-        }
-        const update = db.prepare('UPDATE memories SET retrieval_count = ?, last_retrieved = ?, half_life_days = ?, strength = ? WHERE id = ?');
-        for (const e of markRetrieved(live)) {
-            update.run(e.retrieval_count, e.last_retrieved, e.half_life_days, e.strength, e.id);
-            found.add(e.id);
-        }
+        for (const id of strengthenRetrievedOn(db, ids, tenantId))
+            found.add(id);
         db.exec('COMMIT');
     }
     catch (error) {
@@ -1379,6 +1367,27 @@ export function strengthenRetrieved(hippoRoot, ids, tenantId) {
     }
     return found;
 }
+/** strengthenRetrieved on the caller's handle, inside the caller's transaction. Throws; the caller decides. */
+export function strengthenRetrievedOn(db, ids, tenantId) {
+    const found = new Set();
+    if (ids.length === 0 || isRecallBoostAblated())
+        return found;
+    const tenantClause = tenantId !== undefined ? ' AND tenant_id = ?' : '';
+    const select = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id = ?${tenantClause}`);
+    const live = [];
+    for (const id of ids) {
+        // SAFETY: the SELECT names exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
+        const row = (tenantId !== undefined ? select.get(id, tenantId) : select.get(id));
+        if (row)
+            live.push(rowToEntry(row));
+    }
+    const update = db.prepare('UPDATE memories SET retrieval_count = ?, last_retrieved = ?, half_life_days = ?, strength = ? WHERE id = ?');
+    for (const e of markRetrieved(live)) {
+        update.run(e.retrieval_count, e.last_retrieved, e.half_life_days, e.strength, e.id);
+        found.add(e.id);
+    }
+    return found;
+}
 /**
  * All `kind='raw'` rows for a given session, tenant-scoped, returned
  * oldest-first. Used by `api.assemble` to walk a session's chronological
@@ -1538,6 +1547,34 @@ export function loadChildrenOf(hippoRoot, parentId, tenantId) {
         closeHippoDb(db);
     }
 }
+/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL); tests/dormant-memories.test.ts pins it to the schema. */
+export const MEMORY_BACKED_TABLES = ['predictions', 'decisions', 'incidents', 'processes', 'policies', 'skills', 'project_briefs', 'customer_notes'];
+/** Deleting a memory that backs an object nulls the object's link, and no restore can repair it, so no automatic pass may. */
+const AUTOMATIC_DELETE_SQL = `${AUTO_DELETABLE_SQL}${MEMORY_BACKED_TABLES.map((t) => ` AND NOT EXISTS (SELECT 1 FROM ${t} WHERE ${t}.memory_id = memories.id)`).join('')}`;
+/** Ids of memories that back a first-class object, for passes that plan deletes before making them. A table missing from an older schema is skipped. */
+export function memoriesBackingObjects(hippoRoot) {
+    const ids = new Set();
+    const db = openHippoDb(hippoRoot);
+    try {
+        for (const table of MEMORY_BACKED_TABLES) {
+            try {
+                // SAFETY: SELECT of one nullable TEXT column, filtered to non-null.
+                const rows = db.prepare(`SELECT memory_id FROM ${table} WHERE memory_id IS NOT NULL`).all();
+                for (const r of rows)
+                    ids.add(r.memory_id);
+            }
+            catch (err) {
+                // A missing table is an older schema; any other error could hide a backing memory, so the caller stops.
+                if (!(err instanceof Error && err.message.includes('no such table')))
+                    throw err;
+            }
+        }
+    }
+    finally {
+        closeHippoDb(db);
+    }
+    return ids;
+}
 /**
  * AT1 (plan §4, round-2 fix, designed from source): db-scoped delete core.
  * `deleteEntry` used to open+close its OWN connection, which meant it could
@@ -1555,7 +1592,7 @@ export function loadChildrenOf(hippoRoot, parentId, tenantId) {
  * Default keeps `deleteEntry` byte-identical to its pre-split behavior.
  *
  * Returns `{tenantId, dagParentId}` for the removed row, or `null` if no row with `id`
- * existed or `automatic` refused it (pinned or raw at DELETE time, so a late pin wins).
+ * existed or `automatic` refused it (pinned, raw, kept for good or backing an object at DELETE time, so a late pin wins).
  */
 export function deleteEntryCore(db, id, opts) {
     // SAFETY: row's shape matches the three columns named in the SELECT above.
@@ -1564,7 +1601,7 @@ export function deleteEntryCore(db, id, opts) {
         .get(id);
     if (!row?.id)
         return null;
-    const guard = opts?.automatic ? ` AND ${AUTO_DELETABLE_SQL}` : '';
+    const guard = opts?.automatic ? ` AND ${AUTOMATIC_DELETE_SQL}` : '';
     if (Number(db.prepare(`DELETE FROM memories WHERE id = ?${guard}`).run(id).changes ?? 0) === 0)
         return null;
     deleteFtsRow(db, id);
@@ -1622,7 +1659,7 @@ function mergeOwnChanges(base, ours, live) {
  *  `dormant` (src/dormant.ts): each move's snapshot is inserted into `dormant_memories` and its `memories` row
  *  leaves exactly like a delete (FTS row, DAG parent dirty-mark, mirrors), in the same transaction, so a memory
  *  is never in both places or in neither. Deletes and moves both skip rows that are no longer auto-deletable
- *  (pinned or raw since the caller decided). Returns the ids that left `memories`, deleted or moved. */
+ *  (pinned, raw, kept for good or backing an object since the caller decided). Returns the ids that left `memories`, deleted or moved. */
 export function batchWriteAndDelete(hippoRoot, toWrite, toDeleteIds, opts) {
     const dormantMoves = opts?.dormant ?? [];
     if (toWrite.length === 0 && toDeleteIds.length === 0 && dormantMoves.length === 0)
@@ -1650,7 +1687,7 @@ export function batchWriteAndDelete(hippoRoot, toWrite, toDeleteIds, opts) {
             const placeholders = toDeleteIds.map(() => '?').join(',');
             // A row pinned after the caller decided to delete it survives.
             // SAFETY: rows' shape matches the three columns named in the SELECT.
-            const rows = db.prepare(`SELECT id, dag_parent_id, tenant_id FROM memories WHERE id IN (${placeholders}) AND ${AUTO_DELETABLE_SQL}`).all(...toDeleteIds);
+            const rows = db.prepare(`SELECT id, dag_parent_id, tenant_id FROM memories WHERE id IN (${placeholders}) AND ${AUTOMATIC_DELETE_SQL}`).all(...toDeleteIds);
             for (const row of rows) {
                 deletableIds.push(row.id);
                 if (row.dag_parent_id) {
@@ -1737,7 +1774,7 @@ export function batchWriteAndDelete(hippoRoot, toWrite, toDeleteIds, opts) {
             const byId = new Map(dormantMoves.map((m) => [m.entry.id, m]));
             const placeholders = dormantMoves.map(() => '?').join(',');
             // SAFETY: rows' shape matches the three columns named in the SELECT.
-            const rows = db.prepare(`SELECT id, dag_parent_id, tenant_id FROM memories WHERE id IN (${placeholders}) AND ${AUTO_DELETABLE_SQL}`).all(...byId.keys());
+            const rows = db.prepare(`SELECT id, dag_parent_id, tenant_id FROM memories WHERE id IN (${placeholders}) AND ${AUTOMATIC_DELETE_SQL}`).all(...byId.keys());
             for (const row of rows) {
                 movable.push(byId.get(row.id));
                 if (row.dag_parent_id) {
@@ -1810,6 +1847,25 @@ export function selectAllEntries(db, tenantId) {
         : db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories ORDER BY created ASC, id ASC`).all();
     return rows.map(rowToEntry);
 }
+/** Live rows whose source starts with `prefix`, on the caller's handle; LIKE folds case, so the prefix is checked again exactly. */
+export function selectLiveEntriesBySourcePrefix(db, tenantId, prefix) {
+    // SAFETY: selects exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
+    const rows = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE tenant_id = ? AND superseded_by IS NULL AND source LIKE ? ESCAPE '\\'`).all(tenantId, `${prefix.replace(/[%_\\]/g, '\\$&')}%`);
+    return rows.map(rowToEntry).filter((entry) => entry.source.startsWith(prefix));
+}
+/** Rewrites a live row's tags and its full-text row on the caller's transaction, with no audit row. */
+export function setEntryTagsInTx(db, entry) {
+    db.prepare(`UPDATE memories SET tags_json = ?, updated_at = datetime('now') WHERE id = ? AND tenant_id = ?`)
+        .run(JSON.stringify(entry.tags), entry.id, entry.tenantId);
+    syncFtsRow(db, entry);
+}
+/** Removes a row from `memories` and full-text search on the caller's transaction, as sleep's dormant move does, and marks its summary parent dirty. */
+export function deleteEntryRowInTx(db, entry, actor) {
+    db.prepare('DELETE FROM memories WHERE id = ? AND tenant_id = ?').run(entry.id, entry.tenantId);
+    deleteFtsRow(db, entry.id);
+    if (entry.dag_parent_id)
+        markSummaryDirtyInTx(db, entry.dag_parent_id, entry.tenantId, actor);
+}
 // Content of every tenant row tagged `tag`, without reading the rest of the store.
 // `instr` is a substring prefilter over the raw JSON; `includes` below re-checks exactly.
 export function loadContentsWithTag(hippoRoot, tenantId, tag) {

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.9";
+export declare const PACKAGE_VERSION = "1.53.1";
 /** 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.9';
+export const PACKAGE_VERSION = '1.53.1';
 /** 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

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Memory for AI agents that learns what is wrong and ranks it down. Injects context at session start and captures errors.",
-  "version": "1.52.9",
+  "version": "1.53.1",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

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

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Memory for AI agents that learns what is wrong and ranks it down. Injects context at session start and captures errors.",
-  "version": "1.52.9",
+  "version": "1.53.1",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.52.9",
+  "version": "1.53.1",
   "description": "Memory for AI agents that learns what is wrong and ranks it down. MCP server, hooks for Claude Code, OpenCode and Codex, AGENTS.md instructions for Codex, Cursor, OpenClaw and Pi. SQLite, zero runtime deps.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",