hippo-memory 2.0.0 → 2.1.0

package/dist/db/migrations/v38.js

@@ -33,8 +33,10 @@ const RELATIONS_TABLE = `
           FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE SET NULL
         )
       `;
-// entities guard (dual-provenance): at least one valid provenance, no raw. Memory path: source_kind must equal the FK'd memory's kind, plus tenant-match.
-// Object path (memory_id NULL): (type,id) must point at an existing same-tenant object with status active|superseded (4-way CASE per table); all-null aborts.
+// entities guard (dual-provenance): at least one valid provenance, no raw. Memory path: source_kind must equal the FK'd
+// memory's kind, plus tenant-match.
+// Object path (memory_id NULL): (type,id) must point at an existing same-tenant object with status active|superseded
+// (4-way CASE per table); all-null aborts.
 const TRG_ENTITIES_CONSOLIDATED_ONLY_INSERT = `
         CREATE TRIGGER IF NOT EXISTS trg_entities_consolidated_only_insert
         BEFORE INSERT ON entities
@@ -197,7 +199,8 @@ const TRG_RELATIONS_CONSOLIDATED_ONLY_UPDATE = `
           END;
         END
       `;
-// Recreated verbatim from v37 (relation endpoints cannot move cross-tenant). The memories and graph queue triggers survive: those tables are not dropped.
+// Recreated verbatim from v37 (relation endpoints cannot move cross-tenant). The memories and graph queue triggers
+// survive: those tables are not dropped.
 const TRG_ENTITIES_NO_TENANT_MOVE_WHEN_REFERENCED = `
         CREATE TRIGGER IF NOT EXISTS trg_entities_no_tenant_move_when_referenced
         BEFORE UPDATE ON entities
@@ -210,8 +213,10 @@ const TRG_ENTITIES_NO_TENANT_MOVE_WHEN_REFERENCED = `
 export const v38 = {
     version: 38,
     up: (db) => {
-        // Anchor graph provenance to the authoritative object, not the decaying mirror memory; the graph is a derived cache, so entities/relations are recreated.
-        // memory_id is NULLABLE ON DELETE SET NULL; node:sqlite fires the BEFORE UPDATE guard on that SET NULL, so the UPDATE triggers omit the all-null ABORT.
+        // Anchor graph provenance to the authoritative object, not the decaying mirror memory; the graph is a derived
+        // cache, so entities/relations are recreated.
+        // memory_id is NULLABLE ON DELETE SET NULL; node:sqlite fires the BEFORE UPDATE guard on that SET NULL, so the
+        // UPDATE triggers omit the all-null ABORT.
         recreateGraphTables(db);
         createGraphGuards(db);
     },

package/dist/db/migrations/v39.js

@@ -11,16 +11,22 @@ export const v39 = {
         if (!tableHasColumn(db, 'memories', 'origin_project')) {
             db.exec(`ALTER TABLE memories ADD COLUMN origin_project TEXT`);
         }
-        // Backfill from store location only (no path-tag guessing): 'shared:<project>:<ts>' rows take <project> (home-dir basename maps to '' user-global);
-        // every other row takes this store's origin (`<project>/.hippo` -> '<project>', global store -> ''). Rows stay NULL only when no hippoRoot was provided.
+        // Backfill from store location only (no path-tag guessing): 'shared:<project>:<ts>' rows take <project> (home-dir
+        // basename maps to '' user-global);
+        // every other row takes this store's origin (`<project>/.hippo` -> '<project>', global store -> ''). Rows stay
+        // NULL only when no hippoRoot was provided.
         const hippoRoot = ctx?.hippoRoot;
         if (hippoRoot) {
-            // Provenance-source evidence first (shared:<project>: / promoted:<localRoot>, parsed by the markdown-import stamp's helper),
+            // Provenance-source evidence first (shared:<project>: / promoted:<localRoot>, parsed by the markdown-import
+            // stamp's helper),
             // then the store's own location for everything else.
             const homeName = path.basename(os.homedir()).toLowerCase();
             // SAFETY: sourcedRows' shape matches the two columns (id, source)
             // named in the SELECT above.
-            const sourcedRows = db.prepare(`SELECT id, source FROM memories WHERE origin_project IS NULL AND (source LIKE 'shared:%' OR source LIKE 'promoted:%')`).all();
+            const sourcedRows = db
+                .prepare(`SELECT id, source FROM memories WHERE origin_project IS NULL ` +
+                `AND (source LIKE 'shared:%' OR source LIKE 'promoted:%')`)
+                .all();
             const setOrigin = db.prepare(`UPDATE memories SET origin_project = ? WHERE id = ?`);
             for (const row of sourcedRows) {
                 const origin = originFromSource(row.source, homeName);
@@ -28,14 +34,16 @@ export const v39 = {
                     continue;
                 setOrigin.run(origin, row.id);
             }
-            // The global root itself is always user-global (''), whatever surrounds it on disk: a HIPPO_HOME inside a dotfiles git repo
+            // The global root itself is always user-global (''), whatever surrounds it on disk: a HIPPO_HOME inside a
+            // dotfiles git repo
             // must not stamp the whole corpus with that repo's name.
             const storeOrigin = isGlobalStoreRoot(hippoRoot)
                 ? ''
                 : deriveOriginProject(path.dirname(hippoRoot));
             db.prepare(`UPDATE memories SET origin_project = ? WHERE origin_project IS NULL`).run(storeOrigin);
         }
-        // Rollback-safety guard: a pre-isolation binary would ignore origin_project and the secret veto and resume injecting cross-project rows.
+        // Rollback-safety guard: a pre-isolation binary would ignore origin_project and the secret veto and resume
+        // injecting cross-project rows.
         // 1.24.0 is the first version with isolation; forward-only, never lower an existing minimum.
         raiseMinBinary(db, '1.24.0');
     },

package/dist/db/migrations/v40.js

@@ -48,8 +48,10 @@ const RECALL_TRACES_SCHEMA_SQL = `
 export const v40 = {
     version: 40,
     up: (db) => {
-        // Retrieval-trace persistence: one trace row per recall, a WITHOUT ROWID results table, append-only outcomes (audit_log pruning must not erase them).
-        // No min_compatible_binary bump on purpose: old binaries ignore these tables and recordTraceOutcome re-validates trace ids; a bump would lock them out.
+        // Retrieval-trace persistence: one trace row per recall, a WITHOUT ROWID results table, append-only outcomes
+        // (audit_log pruning must not erase them).
+        // No min_compatible_binary bump on purpose: old binaries ignore these tables and recordTraceOutcome re-validates
+        // trace ids; a bump would lock them out.
         db.exec(RECALL_TRACES_SCHEMA_SQL);
     },
 };

package/dist/db/migrations/v41.js

@@ -1,8 +1,10 @@
 export const v41 = {
     version: 41,
     up: (db) => {
-        // Rejected-value tombstone: upsertEntryRow refuses writes matching a row's digest. No raw content stored (may be secret); no FK: it outlives its row.
-        // No min_compatible_binary bump, a deliberate tradeoff: an old binary writes without the guard until upgraded (see MEMORY_ENVELOPE.md).
+        // Rejected-value tombstone: upsertEntryRow refuses writes matching a row's digest. No raw content stored (may be
+        // secret); no FK: it outlives its row.
+        // No min_compatible_binary bump, a deliberate tradeoff: an old binary writes without the guard until upgraded
+        // (see MEMORY_ENVELOPE.md).
         db.exec(`
         CREATE TABLE IF NOT EXISTS rejected_values (
           tenant_id  TEXT NOT NULL,

package/dist/db/migrations/v42.js

@@ -34,7 +34,8 @@ export const v42 = {
         if (!tableHasColumn(db, 'session_handoffs', 'card_id')) {
             db.exec(`ALTER TABLE session_handoffs ADD COLUMN card_id TEXT`);
         }
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_outcome ON session_handoffs(tenant_id, outcome, created_at DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_outcome ` +
+            `ON session_handoffs(tenant_id, outcome, created_at DESC)`);
     },
 };
 //# sourceMappingURL=v42.js.map

package/dist/db/migrations/v44.js

@@ -1,8 +1,10 @@
 export const v44 = {
     version: 44,
     up: (db) => {
-        // Dormant memories (src/store/dormant.ts): with `dormant.enabled`, sleep moves a faded memory here; `hippo dormant restore` writes entry_json back.
-        // No FK to memories (the row is gone by design). Additive only: no min_compatible_binary bump, an older binary ignores the table and keeps deleting.
+        // Dormant memories (src/store/dormant.ts): with `dormant.enabled`, sleep moves a faded memory here; `hippo
+        // dormant restore` writes entry_json back.
+        // No FK to memories (the row is gone by design). Additive only: no min_compatible_binary bump, an older binary
+        // ignores the table and keeps deleting.
         db.exec(`
         CREATE TABLE IF NOT EXISTS dormant_memories (
           tenant_id  TEXT NOT NULL DEFAULT 'default',

package/dist/db/migrations/v45.js

@@ -1,8 +1,10 @@
 export const v45 = {
     version: 45,
     up: (db) => {
-        // Token ledger (src/store/token-ledger.ts): one row per block of memory text handed to an agent; `event` is inject, skip, reset (compaction) or reread.
-        // block_hash lets the per-prompt hook skip an unchanged block; rows past retention are pruned on write. Additive: no min_compatible_binary bump.
+        // Token ledger (src/store/token-ledger.ts): one row per block of memory text handed to an agent; `event` is
+        // inject, skip, reset (compaction) or reread.
+        // block_hash lets the per-prompt hook skip an unchanged block; rows past retention are pruned on write. Additive:
+        // no min_compatible_binary bump.
         db.exec(`
         CREATE TABLE IF NOT EXISTS token_ledger (
           id         INTEGER PRIMARY KEY AUTOINCREMENT,

package/dist/db/migrations/v49.js

@@ -1,7 +1,8 @@
 export const v49 = {
     version: 49,
     up: (db) => {
-        // Compaction record (src/capture/compaction-record.ts): one row per Claude Code compaction, written before it (started)
+        // Compaction record (src/capture/compaction-record.ts): one row per Claude Code compaction, written before it
+        // (started)
         // and after it (summarised, done). Not a memory row. Additive only: no min_compatible_binary bump.
         db.exec(`
         CREATE TABLE IF NOT EXISTS compactions (

package/dist/db/migrations/v50.js

@@ -60,8 +60,10 @@ const DELIVERY_EVENTS_SCHEMA_SQL = `
 export const v50 = {
     version: 50,
     up: (db) => {
-        // Per-turn delivery events (src/store/recall-trace.ts). Additive only: no min_compatible_binary bump; rollback drops both tables
-        // and sets schema_version back to 49. No CHECK on enum columns since SQLite cannot alter one; delivery-recorder.ts unions are the allowlist.
+        // Per-turn delivery events (src/store/recall-trace.ts). Additive only: no min_compatible_binary bump; rollback
+        // drops both tables
+        // and sets schema_version back to 49. No CHECK on enum columns since SQLite cannot alter one;
+        // delivery-recorder.ts unions are the allowlist.
         db.exec(DELIVERY_EVENTS_SCHEMA_SQL);
     },
 };

package/dist/db/migrations/v51.js

@@ -1,8 +1,10 @@
 export const v51 = {
     version: 51,
     up: (db) => {
-        // Both indexes serve loadAmbientCandidates (src/store/candidates.ts); their WHERE text must match its SQL for the planner to pick them.
-        // The drift index stays empty on a healthy store, so the drift probe is one index seek instead of a tenant scan. Additive only.
+        // Both indexes serve loadAmbientCandidates (src/store/candidates.ts); their WHERE text must match its SQL for the
+        // planner to pick them.
+        // The drift index stays empty on a healthy store, so the drift probe is one index seek instead of a tenant scan.
+        // Additive only.
         db.exec(`
         CREATE INDEX IF NOT EXISTS idx_memories_pinned
           ON memories(tenant_id, created, id) WHERE pinned = 1;

package/dist/db/migrations/v52.js

@@ -1,7 +1,8 @@
 import { MEMORY_VECTORS_DDL } from '../vector-store.js';
 export const v52 = {
     version: 52,
-    // Vectors move out of embeddings.json so hybrid search reads only the rows it ranks. Additive only; the JSON import runs after COMMIT.
+    // Vectors move out of embeddings.json so hybrid search reads only the rows it ranks. Additive only; the JSON import
+    // runs after COMMIT.
     up: (db) => db.exec(MEMORY_VECTORS_DDL),
 };
 //# sourceMappingURL=v52.js.map

package/dist/db/migrations/v53.js

@@ -2,14 +2,18 @@ import { tableHasColumn, tableExists } from '../tables.js';
 export const v53 = {
     version: 53,
     up: (db) => {
-        // Self-service keys record who minted them and when they stop working; both stay null for keys minted before this.
-        // No floor raise here: a store with no expiring key is safe for older binaries, so the first expiring key raises it.
+        // Self-service keys record who minted them and when they
+        // stop working; both stay null for keys minted before this.
+        // No floor raise here: a store with no expiring key is safe
+        // for older binaries, so the first expiring key raises it.
         if (tableExists(db, 'api_keys')) {
-            if (!tableHasColumn(db, 'api_keys', 'owner_subject'))
+            if (!tableHasColumn(db, 'api_keys', 'owner_subject')) {
                 db.exec(`ALTER TABLE api_keys ADD COLUMN owner_subject TEXT`);
+            }
             if (!tableHasColumn(db, 'api_keys', 'expires_at'))
                 db.exec(`ALTER TABLE api_keys ADD COLUMN expires_at TEXT`);
-            db.exec(`CREATE INDEX IF NOT EXISTS idx_api_keys_live_owner ON api_keys(tenant_id, owner_subject) WHERE revoked_at IS NULL`);
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_api_keys_live_owner ` +
+                `ON api_keys(tenant_id, owner_subject) WHERE revoked_at IS NULL`);
         }
     },
 };

package/dist/db/migrations/v54.js

@@ -14,7 +14,8 @@ export const v54 = {
     version: 54,
     up: (db) => {
         // Rows from before this stay NULL: no backfill, so they never match an owner's key.
-        // No floor raise here: the first session bind or owner snapshot raises it, so an unused store stays open to older binaries.
+        // No floor raise here: the first session bind or owner snapshot raises it, so an unused store stays open to older
+        // binaries.
         for (const [t, c] of OWNER_COLUMNS) {
             if (tableExists(db, t) && !tableHasColumn(db, t, c))
                 db.exec(`ALTER TABLE ${t} ADD COLUMN ${c} TEXT`);

package/dist/db/migrations/v55.js

@@ -5,10 +5,12 @@ export const v55 = {
         // No backfill and no floor raise: an older binary names its INSERT columns, so it still writes.
         if (!tableExists(db, 'delivery_events'))
             return;
-        if (!tableHasColumn(db, 'delivery_events', 'tool_use_id'))
+        if (!tableHasColumn(db, 'delivery_events', 'tool_use_id')) {
             db.exec('ALTER TABLE delivery_events ADD COLUMN tool_use_id TEXT');
-        if (!tableHasColumn(db, 'delivery_events', 'failure_id'))
+        }
+        if (!tableHasColumn(db, 'delivery_events', 'failure_id')) {
             db.exec('ALTER TABLE delivery_events ADD COLUMN failure_id INTEGER');
+        }
         db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_delivery_events_tool_call
         ON delivery_events(tenant_id, session_id, tool_use_id)
         WHERE tool_use_id IS NOT NULL AND turn_seq IS NOT NULL`);

package/dist/db/migrations/v56.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v56: Migration;
+//# sourceMappingURL=v56.d.ts.map

package/dist/db/migrations/v56.js

@@ -0,0 +1,28 @@
+import { tableExists } from '../tables.js';
+const OBJECT_TABLES = [
+    'decisions',
+    'incidents',
+    'processes',
+    'policies',
+    'skills',
+    'project_briefs',
+    'customer_notes',
+];
+export const v56 = {
+    version: 56,
+    up: (db) => {
+        // The list order is part of the key, so a page by status reads in index order with no sort; the old (tenant_id,
+        // status) index stays.
+        for (const table of OBJECT_TABLES) {
+            if (!tableExists(db, table))
+                continue;
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_${table}_tenant_status_created ` +
+                `ON ${table}(tenant_id, status, created_at DESC, id DESC)`);
+        }
+        // Source leads so a tenant-only query cannot pick this over idx_memories_tenant_created and change the order of
+        // its unsorted rows;
+        // created and id let a per-source read come back in store order with no sort.
+        db.exec('CREATE INDEX IF NOT EXISTS idx_memories_source_tenant_created ON memories(source, tenant_id, created, id)');
+    },
+};
+//# sourceMappingURL=v56.js.map

package/dist/db/open.d.ts

@@ -1,32 +1,42 @@
 import { type DatabaseSyncLike } from './sqlite.js';
 import { getHippoDbPath, type OpenedDb } from './connect.js';
 export { getHippoDbPath };
-/** Lock wait for hook commands: under the 5 s prompt-hook budget even after a few skipped writes, and far above a normal write's hold. */
+/** Lock wait for hook commands: under the 5 s prompt-hook budget even after a few skipped writes, and far above a
+ * normal write's hold. */
 export declare const HOOK_DB_WAIT_MS = 1000;
-/** Lock wait inside an HTTP request: SQLite waits synchronously, so a long wait would stall every other request on the event loop. */
+/** Lock wait inside an HTTP request: SQLite waits synchronously, so a long wait would stall every other request on
+ * the event loop. */
 export declare const SERVER_DB_WAIT_MS = 250;
 /** A busy store made a command skip work: warn once per process (the holder is usually `hippo sleep`). */
 export declare function noteStoreBusy(skipped: string): void;
-/** Runs `fn` with one handle per store: openHippoDb reuses it and closeHippoDb leaves it open until `fn` settles or the process exits.
+/** Runs `fn` with one handle per store: openHippoDb reuses it and closeHippoDb leaves it open until `fn` settles or the
+ * process exits.
  *  `busyWaitMs` is the lock wait of every open inside `fn` that does not pass its own. */
 export declare function withSharedStoreHandles<T>(fn: () => T | Promise<T>, opts?: {
     busyWaitMs?: number;
 }): Promise<T>;
-/** Lock wait for each of sleep's short write transactions, even inside a server request: a run stops only on a writer that holds the lock longer. */
+/** Lock wait for each of sleep's short write transactions, even inside a server request: a run stops only on a
+ * writer that holds the lock longer. */
 export declare const SLEEP_DB_WAIT_MS = 5000;
-/** The lock wait an open here would get without its own `busyWaitMs`: the request scope's; undefined outside every scope. */
+/** The lock wait an open here would get without its own `busyWaitMs`: the request scope's; undefined outside every
+ * scope. */
 export declare function scopedBusyWait(): number | undefined;
-/** Runs `fn` so that every hippo.db open inside it, across awaits, throws; otherwise a missed port would create and write a hippo.db nobody reads. */
+/** Runs `fn` so that every hippo.db open inside it, across awaits, throws; otherwise a missed port would create and
+ * write a hippo.db nobody reads. */
 export declare function withSqliteBlocked<T>(storeKind: string, fn: () => T): T;
-/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db, or a copy that reads the old hippo.db. */
+/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db, or a copy that
+ * reads the old hippo.db. */
 export declare function withSqliteAllowed<T>(fn: () => T): T;
-/** Runs `fn` so that a hippo.db open on this thread throws, across awaits; a block of another store, when one is open, already refuses and stays as it is. */
+/** Runs `fn` so that a hippo.db open on this thread throws, across awaits; a block of another store, when one is
+ * open, already refuses and stays as it is. */
 export declare function withSqliteOffLoop<T>(fn: () => T): T;
-/** Leaves withSqliteOffLoop's block and nothing else: another store's block and the folder marker still refuse, which withSqliteAllowed would waive. */
+/** Leaves withSqliteOffLoop's block and nothing else: another store's block and the folder marker still refuse,
+ * which withSqliteAllowed would waive. */
 export declare function outsideSqliteOffLoop<T>(fn: () => T): T;
 /** store init --db, store copy --db and serve --db write this file in the hippo root; its text is the store kind. */
 export declare const OTHER_STORE_MARKER = "other-store";
-/** Throws where hippo.db must not open; checked on every open, not cached, since the marker can appear while a process runs. */
+/** Throws where hippo.db must not open; checked on every open, not cached, since the marker can appear while a
+ * process runs. */
 export declare function assertSqliteAllowed(hippoRoot: string): void;
 /** `busyWaitMs` shortens every lock wait of this open, for a hook that must finish inside its own timeout. */
 export declare function openHippoDb(hippoRoot: string, opts?: {
@@ -36,9 +46,11 @@ export declare function openHippoDb(hippoRoot: string, opts?: {
 export declare function openHippoDbWithFacts(hippoRoot: string, opts?: {
     busyWaitMs?: number;
 }): OpenedDb;
-/** Open an existing store without changing it: no mkdir, WAL switch, migration or mirror cleanup. Throws when hippo.db is missing. */
+/** Open an existing store without changing it: no mkdir, WAL switch, migration or mirror cleanup. Throws when
+ * hippo.db is missing. */
 export declare function openHippoDbReadOnly(hippoRoot: string): DatabaseSyncLike;
-/** Runs `fn` on an existing hippo.db opened without migrations, for a repair of a store whose schema is behind; closes it after. */
+/** Runs `fn` on an existing hippo.db opened without migrations, for a repair of a store whose schema is behind;
+ * closes it after. */
 export declare function withUnmigratedDb<T>(hippoRoot: string, readOnly: boolean, fn: (db: DatabaseSyncLike) => T): T;
 export declare function closeHippoDb(db: DatabaseSyncLike): void;
 //# sourceMappingURL=open.d.ts.map

package/dist/db/open.js

@@ -10,43 +10,52 @@ import { connectWithFacts, getHippoDbPath } from './connect.js';
 import { currentRequestStores, isScopedHandle, runWithRequestStores } from './request-stores.js';
 import { OtherStoreFolderError, SqliteBlockedError } from '../util/sqlite-blocked.js';
 export { getHippoDbPath };
-/** Lock wait for hook commands: under the 5 s prompt-hook budget even after a few skipped writes, and far above a normal write's hold. */
+/** Lock wait for hook commands: under the 5 s prompt-hook budget even after a few skipped writes, and far above a
+ * normal write's hold. */
 export const HOOK_DB_WAIT_MS = 1000;
-/** Lock wait inside an HTTP request: SQLite waits synchronously, so a long wait would stall every other request on the event loop. */
+/** Lock wait inside an HTTP request: SQLite waits synchronously, so a long wait would stall every other request on
+ * the event loop. */
 export const SERVER_DB_WAIT_MS = 250;
 /** A busy store made a command skip work: warn once per process (the holder is usually `hippo sleep`). */
 export function noteStoreBusy(skipped) {
     log.once('store-busy', 'warn', `store busy (another hippo process holds the write lock); ${skipped}`);
     currentRequestStores()?.noteBusy();
 }
-/** Runs `fn` with one handle per store: openHippoDb reuses it and closeHippoDb leaves it open until `fn` settles or the process exits.
+/** Runs `fn` with one handle per store: openHippoDb reuses it and closeHippoDb leaves it open until `fn` settles or the
+ * process exits.
  *  `busyWaitMs` is the lock wait of every open inside `fn` that does not pass its own. */
 export async function withSharedStoreHandles(fn, opts) {
     return runWithRequestStores(fn, { busyWaitMs: opts?.busyWaitMs });
 }
-/** Lock wait for each of sleep's short write transactions, even inside a server request: a run stops only on a writer that holds the lock longer. */
+/** Lock wait for each of sleep's short write transactions, even inside a server request: a run stops only on a
+ * writer that holds the lock longer. */
 export const SLEEP_DB_WAIT_MS = 5000;
-/** The lock wait an open here would get without its own `busyWaitMs`: the request scope's; undefined outside every scope. */
+/** The lock wait an open here would get without its own `busyWaitMs`: the request scope's; undefined outside every
+ * scope. */
 export function scopedBusyWait() {
     return currentRequestStores()?.busyWaitMs;
 }
 const sqliteBlockedBy = new AsyncLocalStorage();
-/** Runs `fn` so that every hippo.db open inside it, across awaits, throws; otherwise a missed port would create and write a hippo.db nobody reads. */
+/** Runs `fn` so that every hippo.db open inside it, across awaits, throws; otherwise a missed port would create and
+ * write a hippo.db nobody reads. */
 export function withSqliteBlocked(storeKind, fn) {
     return sqliteBlockedBy.run(storeKind, fn);
 }
-/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db, or a copy that reads the old hippo.db. */
+/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db, or a copy that
+ * reads the old hippo.db. */
 export function withSqliteAllowed(fn) {
     return sqliteBlockedBy.exit(() => markerWaived.run(true, fn));
 }
 // Not a store kind: the block of a route whose SQLite work belongs on a worker thread, under the hippo.db store itself.
 const OFF_LOOP = 'sqlite (off the event loop)';
 const OFF_LOOP_MESSAGE = 'hippo.db was opened on the server thread by a route whose SQLite work runs on a worker thread';
-/** Runs `fn` so that a hippo.db open on this thread throws, across awaits; a block of another store, when one is open, already refuses and stays as it is. */
+/** Runs `fn` so that a hippo.db open on this thread throws, across awaits; a block of another store, when one is
+ * open, already refuses and stays as it is. */
 export function withSqliteOffLoop(fn) {
     return sqliteBlockedBy.getStore() === undefined ? sqliteBlockedBy.run(OFF_LOOP, fn) : fn();
 }
-/** Leaves withSqliteOffLoop's block and nothing else: another store's block and the folder marker still refuse, which withSqliteAllowed would waive. */
+/** Leaves withSqliteOffLoop's block and nothing else: another store's block and the folder marker still refuse,
+ * which withSqliteAllowed would waive. */
 export function outsideSqliteOffLoop(fn) {
     return sqliteBlockedBy.getStore() === OFF_LOOP ? sqliteBlockedBy.exit(fn) : fn();
 }
@@ -59,11 +68,12 @@ function markerKind(marker) {
         return readFileSync(marker, 'utf8').trim() || 'unknown';
     }
     catch (err) {
-        log.debug(`${marker} is unreadable, so its store kind reads as unknown: ${errorMessage(err)}`);
+        log.warn(`${marker} is unreadable, so its store kind reads as unknown: ${errorMessage(err)}`, errorFields(err));
         return 'unknown';
     }
 }
-/** Throws where hippo.db must not open; checked on every open, not cached, since the marker can appear while a process runs. */
+/** Throws where hippo.db must not open; checked on every open, not cached, since the marker can appear while a
+ * process runs. */
 export function assertSqliteAllowed(hippoRoot) {
     const storeKind = sqliteBlockedBy.getStore();
     if (storeKind === OFF_LOOP)
@@ -86,7 +96,8 @@ export function openHippoDbWithFacts(hippoRoot, opts) {
     const stores = currentRequestStores();
     return stores ? stores.getWithFacts(hippoRoot, opts) : connectWithFacts(hippoRoot, opts?.busyWaitMs);
 }
-/** Open an existing store without changing it: no mkdir, WAL switch, migration or mirror cleanup. Throws when hippo.db is missing. */
+/** Open an existing store without changing it: no mkdir, WAL switch, migration or mirror cleanup. Throws when
+ * hippo.db is missing. */
 export function openHippoDbReadOnly(hippoRoot) {
     assertSqliteAllowed(hippoRoot);
     const db = new DatabaseSync(getHippoDbPath(hippoRoot), { readOnly: true });
@@ -106,7 +117,8 @@ export function openHippoDbReadOnly(hippoRoot) {
         throw error;
     }
 }
-/** Runs `fn` on an existing hippo.db opened without migrations, for a repair of a store whose schema is behind; closes it after. */
+/** Runs `fn` on an existing hippo.db opened without migrations, for a repair of a store whose schema is behind;
+ * closes it after. */
 export function withUnmigratedDb(hippoRoot, readOnly, fn) {
     // Skips openHippoDb, so it takes the same refusal itself.
     assertSqliteAllowed(hippoRoot);

package/dist/db/physics-state.d.ts

@@ -1,4 +1,7 @@
-/** Physics state persistence: particle state (position, velocity, mass, charge, temperature) in SQLite, with BLOB columns for 384-dim vectors. */
+/**
+ * Physics state persistence: particle state (position, velocity, mass, charge, temperature) in SQLite, with BLOB
+ * columns for 384-dim vectors.
+ */
 import type { DatabaseSyncLike } from './index.js';
 import type { MemoryEntry } from '../core/memory.js';
 import type { PhysicsParticle } from '../core/physics.js';
@@ -12,8 +15,9 @@ export declare function loadPhysicsState(db: DatabaseSyncLike, memoryIds?: strin
  * Save physics state for multiple particles (batch upsert).
  */
 export declare function savePhysicsState(db: DatabaseSyncLike, particles: PhysicsParticle[]): void;
-/** Drops every particle, then seeds one per entry that has an embedding; `entries` may be read lazily, as each batch is written before the next is read. */
+/**
+ * Drops every particle, then seeds one per entry that has an embedding; `entries` may be read lazily, as each batch is
+ * written before the next is read.
+ */
 export declare function resetAllPhysicsState(db: DatabaseSyncLike, entries: Iterable<MemoryEntry>, embeddingIndex: Record<string, number[]>, now?: Date): number;
-/** Refresh mass, charge and temperature for existing particles from current memory attributes (called during consolidation). */
-export declare function refreshParticleProperties(particles: PhysicsParticle[], entries: Map<string, MemoryEntry>, now?: Date): void;
 //# sourceMappingURL=physics-state.d.ts.map

package/dist/db/physics-state.js

@@ -1,9 +1,10 @@
-/** Physics state persistence: particle state (position, velocity, mass, charge, temperature) in SQLite, with BLOB columns for 384-dim vectors. */
-import { evalNow, strengthAblation } from '../core/ablation.js';
+/**
+ * Physics state persistence: particle state (position, velocity, mass, charge, temperature) in SQLite, with BLOB
+ * columns for 384-dim vectors.
+ */
+import { evalNow } from '../core/ablation.js';
 import { withWriteScope } from './busy.js';
-import { computeMass, computeCharge, computeTemperature, initializeParticle } from '../core/physics.js';
-import { calculateStrength } from '../core/memory.js';
-import { DAY_MS } from '../util/time.js';
+import { initializeParticle } from '../core/physics.js';
 import { placeholders } from '../util/sql.js';
 import { bufferToFloat32, float32ToBuffer } from '../util/vector-codec.js';
 // Schema migration
@@ -68,7 +69,9 @@ export function savePhysicsState(db, particles) {
     if (particles.length === 0)
         return;
     const stmt = db.prepare(`
-    INSERT INTO memory_physics (memory_id, position_blob, velocity_blob, mass, charge, temperature, last_simulation, updated_at)
+    INSERT INTO memory_physics (
+      memory_id, position_blob, velocity_blob, mass, charge, temperature, last_simulation, updated_at
+    )
     VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
     ON CONFLICT(memory_id) DO UPDATE SET
       position_blob = excluded.position_blob,
@@ -86,7 +89,10 @@ export function savePhysicsState(db, particles) {
     });
 }
 const RESET_BATCH = 64;
-/** Drops every particle, then seeds one per entry that has an embedding; `entries` may be read lazily, as each batch is written before the next is read. */
+/**
+ * Drops every particle, then seeds one per entry that has an embedding; `entries` may be read lazily, as each batch is
+ * written before the next is read.
+ */
 export function resetAllPhysicsState(db, entries, embeddingIndex, now = evalNow()) {
     db.exec('DELETE FROM memory_physics');
     // One transaction for every batch, so a failure part way leaves no particles rather than some.
@@ -109,17 +115,4 @@ export function resetAllPhysicsState(db, entries, embeddingIndex, now = evalNow(
         return count;
     });
 }
-/** Refresh mass, charge and temperature for existing particles from current memory attributes (called during consolidation). */
-export function refreshParticleProperties(particles, entries, now = evalNow()) {
-    for (const p of particles) {
-        const entry = entries.get(p.memoryId);
-        if (!entry)
-            continue;
-        const strength = calculateStrength(entry, now, { ablation: strengthAblation() });
-        const ageDays = (now.getTime() - new Date(entry.created).getTime()) / DAY_MS;
-        p.mass = computeMass(strength, entry.retrieval_count);
-        p.charge = computeCharge(entry.emotional_valence);
-        p.temperature = computeTemperature(ageDays, 1.0);
-    }
-}
 //# sourceMappingURL=physics-state.js.map

package/dist/db/raw-archive-mirror-cleanup.d.ts

@@ -1,5 +1,7 @@
 import type { DatabaseSyncLike } from './index.js';
-/** Path A backfill cleanup: delete markdown mirrors (<hippoRoot>/<layer>/<id>.md) of rows archived before redaction, so RTBF holds for historical archives.
- * Tracked by raw_archive.mirror_cleaned_at: set only on success, so a failed unlink retries next connection. Returns whether all pending rows were cleaned. */
+/** Path A backfill cleanup: delete markdown mirrors (<hippoRoot>/<layer>/<id>.md) of rows archived before redaction, so
+ * RTBF holds for historical archives.
+ * Tracked by raw_archive.mirror_cleaned_at: set only on success, so a failed unlink retries next connection. Returns
+ * whether all pending rows were cleaned. */
 export declare function cleanupArchivedMirrors(hippoRoot: string, db: DatabaseSyncLike): boolean;
 //# sourceMappingURL=raw-archive-mirror-cleanup.d.ts.map

package/dist/db/raw-archive-mirror-cleanup.js

@@ -1,10 +1,12 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 const LAYERS = ['episodic', 'buffer', 'semantic'];
 const MAX_WARN_LOGS = 5;
-/** Path A backfill cleanup: delete markdown mirrors (<hippoRoot>/<layer>/<id>.md) of rows archived before redaction, so RTBF holds for historical archives.
- * Tracked by raw_archive.mirror_cleaned_at: set only on success, so a failed unlink retries next connection. Returns whether all pending rows were cleaned. */
+/** Path A backfill cleanup: delete markdown mirrors (<hippoRoot>/<layer>/<id>.md) of rows archived before redaction, so
+ * RTBF holds for historical archives.
+ * Tracked by raw_archive.mirror_cleaned_at: set only on success, so a failed unlink retries next connection. Returns
+ * whether all pending rows were cleaned. */
 export function cleanupArchivedMirrors(hippoRoot, db) {
     // SAFETY: the SELECT above names exactly one column, memory_id (raw_archive.memory_id
     // is NOT NULL TEXT), so the row shape matches this assertion.
@@ -29,7 +31,7 @@ export function cleanupArchivedMirrors(hippoRoot, db) {
             catch (err) {
                 allOk = false;
                 if (warnCount < MAX_WARN_LOGS) {
-                    log.warn(`cleanupArchivedMirrors: unlink failed for ${filePath} (will retry on next DB open): ${errorMessage(err)}`);
+                    log.warn(`cleanupArchivedMirrors: unlink failed for ${filePath} (will retry on next DB open): ${errorMessage(err)}`, errorFields(err));
                     warnCount += 1;
                 }
             }

package/dist/db/request-stores.d.ts

@@ -4,9 +4,15 @@ import { type RequestScope } from '../util/request-scope.js';
 export interface RequestStoresOptions {
     /** Lock wait of every open in the scope that does not pass its own. */
     readonly busyWaitMs?: number;
-    /** Set for hook scopes: after one lock wait runs out, {@link RequestStores.noteBusy} makes the scope's later writes skip at once. */
+    /**
+     * Set for hook scopes: after one lock wait runs out, {@link RequestStores.noteBusy} makes the scope's later writes
+     * skip at once.
+     */
     readonly failFastWhenBusy?: boolean;
-    /** The store whose open-time setup another connection has already run, so an open in this scope skips it: a store worker's reader, which cannot write it. */
+    /**
+     * The store whose open-time setup another connection has already run, so an open in this scope skips it: a store
+     * worker's reader, which cannot write it.
+     */
     readonly setupDoneFor?: string;
 }
 /** The handles one request opened, keyed by resolved store path and lock wait. */
@@ -31,13 +37,21 @@ export declare class RequestStores implements RequestScope {
     noteBusy(): void;
     close(): void;
 }
-/** Runs `fn` in a request scope whose handles close when `fn` settles; inside an open scope `fn` joins it and `opts` is ignored. */
+/**
+ * Runs `fn` in a request scope whose handles close when `fn` settles; inside an open scope `fn` joins it and `opts` is
+ * ignored.
+ */
 export declare function runWithRequestStores<T>(fn: () => T | Promise<T>, opts?: RequestStoresOptions): Promise<T>;
-/** runWithRequestStores for a synchronous `fn`, so a batch called from outside any request still opens each store once. */
+/**
+ * runWithRequestStores for a synchronous `fn`, so a batch called from outside any request still opens each store once.
+ */
 export declare function withRequestStoresSync<T>(fn: () => T): T;
 /** The scope this code runs in, if any. A closed scope still answers: its `get` falls through to a plain open. */
 export declare function currentRequestStores(): RequestStores | undefined;
-/** Runs `fn` outside every store scope, for a connection that must outlive the request that happens to open it; its log lines keep the request's id. */
+/**
+ * Runs `fn` outside every store scope, for a connection that must outlive the request that happens to open it; its log
+ * lines keep the request's id.
+ */
 export declare function outsideRequestStores<T>(fn: () => T): T;
 /** Whether a scope owns `db` and will close it itself. */
 export declare function isScopedHandle(db: DatabaseSyncLike): boolean;