hippo-memory 1.71.0 → 2.0.0

package/dist/db/busy.js

@@ -1,3 +1,4 @@
+import { errorFields, errorMessage, log } from '../util/log.js';
 function carriesErrcode(cause) {
     return typeof cause === 'object' && cause !== null && 'errcode' in cause;
 }
@@ -5,21 +6,11 @@ export function isSqliteBusy(cause) {
     const code = carriesErrcode(cause) ? cause.errcode : undefined;
     return code === 5 || code === 6 || code === 517;
 }
-export const STORE_BUSY_MESSAGE = 'store busy (another hippo process holds the write lock); retry shortly';
-/** A store behind the port throws this when its lock wait runs out, so the server answers 503 as it does for a busy hippo.db. */
-export class StoreBusyError extends Error {
-    constructor(message = STORE_BUSY_MESSAGE, options) {
-        super(message, options);
-        this.name = 'StoreBusyError';
-    }
-}
-/** A held lock in any store: SQLite's busy codes or a port's StoreBusyError. */
-export function isStoreBusy(error) {
-    return error instanceof StoreBusyError || isSqliteBusy(error);
-}
+/** The lock wait of an open that names none: its busy_timeout and every explicit wait below. */
+export const DEFAULT_BUSY_WAIT_MS = 5000;
 // busy_timeout covers neither contended statement here: SQLite skips the busy handler for `PRAGMA journal_mode` and for a write
 // that upgrades a deferred read snapshot, so both need an explicit wait.
-export function execWithBusyRetry(db, sql, timeoutMs = 30000) {
+export function execWithBusyRetry(db, sql, timeoutMs = DEFAULT_BUSY_WAIT_MS) {
     const deadline = Date.now() + timeoutMs;
     const idle = new Int32Array(new SharedArrayBuffer(4));
     for (;;) {
@@ -43,6 +34,17 @@ function undoScope(db, top, name) {
         db.exec(`RELEASE SAVEPOINT ${name}`);
     }
 }
+/** Undo after a failure without letting a failed undo replace the caller's error; an idle handle means SQLite already unwound the scope. */
+function undoAfterFailure(db, top, name) {
+    if (db.isTransaction === false)
+        return;
+    try {
+        undoScope(db, top, name);
+    }
+    catch (undoError) {
+        log.error(`rollback of write scope ${name} failed: ${errorMessage(undoError)}`, errorFields(undoError));
+    }
+}
 /** Runs `fn` as one write: BEGIN IMMEDIATE on an idle handle, else SAVEPOINT `name` inside the caller's transaction.
  *  A deferred scope that reads first cannot wait out another writer, while BEGIN IMMEDIATE waits the open's busy_timeout. */
 export function withWriteScope(db, name, fn, opts) {
@@ -57,10 +59,7 @@ export function withWriteScope(db, name, fn, opts) {
         return result;
     }
     catch (error) {
-        try {
-            undoScope(db, top, name);
-        }
-        catch { /* already rolled back; keep the original error */ }
+        undoAfterFailure(db, top, name);
         throw error;
     }
 }
@@ -77,7 +76,9 @@ export function withReadSnapshot(db, fn) {
         try {
             db.exec('COMMIT');
         }
-        catch { /* snapshot already gone; keep the original error */ }
+        catch (endError) {
+            log.error(`ending read snapshot failed: ${errorMessage(endError)}`, errorFields(endError));
+        }
         throw error;
     }
     db.exec('COMMIT');
@@ -92,10 +93,7 @@ export function withTrialScope(db, name, fn) {
         result = fn();
     }
     catch (error) {
-        try {
-            undoScope(db, top, name);
-        }
-        catch { /* already rolled back; keep the original error */ }
+        undoAfterFailure(db, top, name);
         throw error;
     }
     undoScope(db, top, name);
@@ -123,10 +121,7 @@ export function withWriteScopeOr(db, name, fn) {
         return result;
     }
     catch (error) {
-        try {
-            undoScope(db, top, name);
-        }
-        catch { /* already rolled back; keep the original error */ }
+        undoAfterFailure(db, top, name);
         throw error;
     }
 }

package/dist/db/connect.d.ts

@@ -1,6 +1,5 @@
 import { type DatabaseSyncLike } from './sqlite.js';
 import { type OpenFacts } from './migrate.js';
-export declare const DEFAULT_BUSY_WAIT_MS = 5000;
 export declare function getHippoDbPath(hippoRoot: string): string;
 /** Runs `step` on this store unless it already ran to the end in this process; a throw leaves it due. */
 export declare function oncePerStore(hippoRoot: string, name: string, step: () => void): void;
@@ -9,6 +8,7 @@ export interface OpenedDb {
     readonly db: DatabaseSyncLike;
     readonly facts: OpenFacts | null;
 }
-/** A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the caller owns and closes it. */
+/** A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the caller owns and closes it.
+ *  Outside any request scope (CLI start-up, timers) this is the only handle there is; openHippoDb reuses the scope's when one exists. */
 export declare function connectWithFacts(hippoRoot: string, busyWaitMs?: number): OpenedDb;
 //# sourceMappingURL=connect.d.ts.map

package/dist/db/connect.js

@@ -3,10 +3,9 @@ import * as path from 'path';
 import { cleanupArchivedMirrors } from './raw-archive-mirror-cleanup.js';
 import { errorFields, errorMessage, log } from '../util/log.js';
 import { DatabaseSync } from './sqlite.js';
-import { execWithBusyRetry } from './busy.js';
+import { DEFAULT_BUSY_WAIT_MS, execWithBusyRetry } from './busy.js';
 import { runMigrations } from './migrate.js';
 import { autoCheckpointPages } from './wal-checkpointer.js';
-export const DEFAULT_BUSY_WAIT_MS = 5000;
 export function getHippoDbPath(hippoRoot) {
     return path.join(hippoRoot, 'hippo.db');
 }
@@ -52,12 +51,13 @@ function archiveTop(db) {
     const row = db.prepare('SELECT MAX(id) AS top FROM raw_archive').get();
     return Number(row?.top ?? 0);
 }
-/** A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the caller owns and closes it. */
-export function connectWithFacts(hippoRoot, busyWaitMs) {
+/** A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the caller owns and closes it.
+ *  Outside any request scope (CLI start-up, timers) this is the only handle there is; openHippoDb reuses the scope's when one exists. */
+export function connectWithFacts(hippoRoot, busyWaitMs = DEFAULT_BUSY_WAIT_MS) {
     createStoreFilesOwnerOnly(hippoRoot);
     const db = new DatabaseSync(getHippoDbPath(hippoRoot));
     try {
-        db.exec(`PRAGMA busy_timeout = ${busyWaitMs ?? DEFAULT_BUSY_WAIT_MS}`);
+        db.exec(`PRAGMA busy_timeout = ${busyWaitMs}`);
         execWithBusyRetry(db, 'PRAGMA journal_mode = WAL', busyWaitMs);
         db.exec('PRAGMA synchronous = NORMAL');
         db.exec(`PRAGMA wal_autocheckpoint = ${autoCheckpointPages(getHippoDbPath(hippoRoot))}`);
@@ -76,8 +76,8 @@ export function connectWithFacts(hippoRoot, busyWaitMs) {
         try {
             db.close();
         }
-        catch {
-            // Best effort only.
+        catch (closeErr) {
+            log.error(`openHippoDb: closing the handle after a failed open failed: ${errorMessage(closeErr)}`, errorFields(closeErr));
         }
         throw error;
     }

package/dist/db/index.d.ts

@@ -1,9 +1,9 @@
 export type { DatabaseSyncLike } from './sqlite.js';
-export { isSqliteBusy, isStoreBusy, StoreBusyError, STORE_BUSY_MESSAGE, execWithBusyRetry, withReadSnapshot, withTrialScope, withWriteScope, withWriteScopeOr } from './busy.js';
+export { isSqliteBusy, execWithBusyRetry, withReadSnapshot, withTrialScope, withWriteScope, withWriteScopeOr } from './busy.js';
 export { getSchemaVersion, getMeta, setMeta, isFtsAvailable } from './meta.js';
-export { countTableRows, pruneConsolidationRuns } from './tables.js';
+export { countTableRows, pruneConsolidationRuns, CONSOLIDATION_RUNS_KEPT } from './tables.js';
 export { getCurrentSchemaVersion, IncompatibleBinaryError, ftsRowCounts, repairFtsDrift } from './migrate.js';
-export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, withSqliteOffLoop, outsideSqliteOffLoop, rethrowIfSqliteBlocked, OTHER_STORE_MARKER, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './open.js';
+export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, withSqliteOffLoop, outsideSqliteOffLoop, OTHER_STORE_MARKER, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './open.js';
 export { RequestStores, runWithRequestStores, currentRequestStores, outsideRequestStores } from './request-stores.js';
 export { OtherStoreFolderError, SqliteBlockedError } from '../util/sqlite-blocked.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/db/index.js

@@ -1,8 +1,8 @@
-export { isSqliteBusy, isStoreBusy, StoreBusyError, STORE_BUSY_MESSAGE, execWithBusyRetry, withReadSnapshot, withTrialScope, withWriteScope, withWriteScopeOr } from './busy.js';
+export { isSqliteBusy, execWithBusyRetry, withReadSnapshot, withTrialScope, withWriteScope, withWriteScopeOr } from './busy.js';
 export { getSchemaVersion, getMeta, setMeta, isFtsAvailable } from './meta.js';
-export { countTableRows, pruneConsolidationRuns } from './tables.js';
+export { countTableRows, pruneConsolidationRuns, CONSOLIDATION_RUNS_KEPT } from './tables.js';
 export { getCurrentSchemaVersion, IncompatibleBinaryError, ftsRowCounts, repairFtsDrift } from './migrate.js';
-export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, withSqliteOffLoop, outsideSqliteOffLoop, rethrowIfSqliteBlocked, OTHER_STORE_MARKER, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './open.js';
+export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, withSqliteOffLoop, outsideSqliteOffLoop, OTHER_STORE_MARKER, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './open.js';
 export { RequestStores, runWithRequestStores, currentRequestStores, outsideRequestStores } from './request-stores.js';
 export { OtherStoreFolderError, SqliteBlockedError } from '../util/sqlite-blocked.js';
 //# sourceMappingURL=index.js.map

package/dist/db/migrate.js

@@ -1,11 +1,12 @@
 import { PACKAGE_VERSION, compareSemver } from '../util/version.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorFields, errorMessage, log } from '../util/log.js';
 import { importLegacyEmbeddingIndex } from './vector-store.js';
 import { execWithBusyRetry, withWriteScope } from './busy.js';
 import { tableExists } from './tables.js';
 import { ensureMetaTable, getMeta, getSchemaVersion, setMeta, setSchemaVersion } from './meta.js';
 import { MEMORIES_FTS_DDL, REQUIRED_SCHEMA_OBJECTS, ensureContinuityIndexes, ensureContinuityTables } from './continuity.js';
 import { CURRENT_SCHEMA_VERSION, MIGRATIONS } from './migrations/index.js';
+import { placeholders } from '../util/sql.js';
 export function getCurrentSchemaVersion() {
     return CURRENT_SCHEMA_VERSION;
 }
@@ -130,7 +131,7 @@ function ensureMetaDefaults(db) {
     const keys = META_DEFAULTS.map(([key]) => key);
     // SAFETY: the statement selects only the `key` column of `meta`, which is TEXT NOT NULL, so each row is { key: string }.
     const present = new Set(db
-        .prepare(`SELECT key FROM meta WHERE key IN (${keys.map(() => '?').join(',')})`)
+        .prepare(`SELECT key FROM meta WHERE key IN (${placeholders(keys.length)})`)
         .all(...keys)
         .map((r) => r.key));
     if (present.size === META_DEFAULTS.length)
@@ -142,18 +143,24 @@ function ensureMetaDefaults(db) {
     }
 }
 function ensureOptionalFts(db) {
-    let available = false;
     try {
         db.exec(MEMORIES_FTS_DDL);
         repairFtsDrift(db);
-        available = true;
     }
     catch (err) {
+        // A busy or locked open says nothing about fts5, so only a missing module may flip the flag.
+        if (!/no such module/i.test(errorMessage(err)) || !/fts5/i.test(errorMessage(err))) {
+            log.warn(`full-text index not set up this open (${errorMessage(err)}); the next open retries`, errorFields(err));
+            return;
+        }
         log.warn(`full-text index unavailable (${errorMessage(err)}); search falls back to slower LIKE matching`);
+        writeFtsFlag(db, '0');
+        return;
     }
-    // Read-first: only write when the flag actually changed, so a healthy
-    // store's open doesn't take a write lock for a same-value upsert.
-    const flag = available ? '1' : '0';
+    writeFtsFlag(db, '1');
+}
+// Read-first: only write when the flag actually changed, so a healthy store's open takes no write lock.
+function writeFtsFlag(db, flag) {
     if (getMeta(db, 'fts5_available') !== flag)
         setMeta(db, 'fts5_available', flag);
 }

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

@@ -1,5 +1,5 @@
 import type { Migration } from './types.js';
-export declare const CURRENT_SCHEMA_VERSION = 54;
+export declare const CURRENT_SCHEMA_VERSION = 55;
 /** Every schema migration in version order; runMigrations applies each one above the stored version. */
 export declare const MIGRATIONS: Migration[];
 //# sourceMappingURL=index.d.ts.map

package/dist/db/migrations/index.js

@@ -52,7 +52,8 @@ import { v51 } from './v51.js';
 import { v52 } from './v52.js';
 import { v53 } from './v53.js';
 import { v54 } from './v54.js';
-export const CURRENT_SCHEMA_VERSION = 54;
+import { v55 } from './v55.js';
+export const CURRENT_SCHEMA_VERSION = 55;
 /** Every schema migration in version order; runMigrations applies each one above the stored version. */
 export const MIGRATIONS = [
     v01,
@@ -109,5 +110,6 @@ export const MIGRATIONS = [
     v52,
     v53,
     v54,
+    v55,
 ];
 //# sourceMappingURL=index.js.map

package/dist/db/migrations/v11.js

@@ -9,6 +9,7 @@ export const v11 = {
         if (!tableHasColumn(db, 'memories', 'superseded_by')) {
             db.exec(`ALTER TABLE memories ADD COLUMN superseded_by TEXT`);
         }
+        // SHORTCUT: overlaps idx_memories_layer_created (v01); dropping it is held until a schema migration is approved.
         db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_current ON memories(layer, created) WHERE superseded_by IS NULL`);
     },
 };

package/dist/db/migrations/v14.js

@@ -48,6 +48,7 @@ export const v14 = {
         if (!tableHasColumn(db, 'memories', 'owner')) {
             db.exec(`ALTER TABLE memories ADD COLUMN owner TEXT`);
         }
+        // SHORTCUT: artifact_ref has no index, so connector deletes and vault lookups scan the tenant; the index is held until a schema migration is approved.
         if (!tableHasColumn(db, 'memories', 'artifact_ref')) {
             db.exec(`ALTER TABLE memories ADD COLUMN artifact_ref TEXT`);
         }

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

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

package/dist/db/migrations/v55.js

@@ -0,0 +1,17 @@
+import { tableHasColumn, tableExists } from '../tables.js';
+export const v55 = {
+    version: 55,
+    up: (db) => {
+        // 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'))
+            db.exec('ALTER TABLE delivery_events ADD COLUMN tool_use_id TEXT');
+        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`);
+    },
+};
+//# sourceMappingURL=v55.js.map

package/dist/db/open.d.ts

@@ -24,8 +24,6 @@ export declare function withSqliteAllowed<T>(fn: () => T): T;
 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. */
 export declare function outsideSqliteOffLoop<T>(fn: () => T): T;
-/** First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently. */
-export declare function rethrowIfSqliteBlocked<E>(err: E): void;
 /** 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. */

package/dist/db/open.js

@@ -1,11 +1,12 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { errorMessage, log } from '../util/log.js';
+import { errorFields, errorMessage, log } from '../util/log.js';
 import { DatabaseSync } from './sqlite.js';
 import { tableExists } from './tables.js';
 import { assertBinaryCompatible } from './migrate.js';
-import { connectWithFacts, DEFAULT_BUSY_WAIT_MS, getHippoDbPath } from './connect.js';
+import { DEFAULT_BUSY_WAIT_MS } from './busy.js';
+import { connectWithFacts, getHippoDbPath } from './connect.js';
 import { currentRequestStores, isScopedHandle, runWithRequestStores } from './request-stores.js';
 import { OtherStoreFolderError, SqliteBlockedError } from '../util/sqlite-blocked.js';
 export { getHippoDbPath };
@@ -49,11 +50,6 @@ export function withSqliteOffLoop(fn) {
 export function outsideSqliteOffLoop(fn) {
     return sqliteBlockedBy.getStore() === OFF_LOOP ? sqliteBlockedBy.exit(fn) : fn();
 }
-/** First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently. */
-export function rethrowIfSqliteBlocked(err) {
-    if (err instanceof SqliteBlockedError)
-        throw err;
-}
 /** store init --db, store copy --db and serve --db write this file in the hippo root; its text is the store kind. */
 export const OTHER_STORE_MARKER = 'other-store';
 const markerWaived = new AsyncLocalStorage();
@@ -95,7 +91,7 @@ export function openHippoDbReadOnly(hippoRoot) {
     assertSqliteAllowed(hippoRoot);
     const db = new DatabaseSync(getHippoDbPath(hippoRoot), { readOnly: true });
     try {
-        db.exec('PRAGMA busy_timeout = 5000');
+        db.exec(`PRAGMA busy_timeout = ${DEFAULT_BUSY_WAIT_MS}`);
         if (tableExists(db, 'meta'))
             assertBinaryCompatible(db);
         return db;
@@ -104,8 +100,8 @@ export function openHippoDbReadOnly(hippoRoot) {
         try {
             db.close();
         }
-        catch {
-            // Best effort only.
+        catch (closeErr) {
+            log.error(`openHippoDbReadOnly: closing the handle after a failed open failed: ${errorMessage(closeErr)}`, errorFields(closeErr));
         }
         throw error;
     }

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

@@ -2,8 +2,6 @@
 import type { DatabaseSyncLike } from './index.js';
 import type { MemoryEntry } from '../core/memory.js';
 import type { PhysicsParticle } from '../core/physics.js';
-export declare function float32ToBuffer(arr: number[]): Buffer;
-export declare function bufferToFloat32(buf: Buffer | Uint8Array): number[];
 /** Create the memory_physics table (migration v8). */
 export declare function createPhysicsTable(db: DatabaseSyncLike): void;
 /**
@@ -14,8 +12,6 @@ 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;
-/** Initialize physics state for a memory from its embedding vector; returns the new particle without persisting (the caller must save). */
-export declare function initializeParticle(entry: MemoryEntry, embedding: number[], now?: Date): PhysicsParticle;
 /** 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). */

package/dist/db/physics-state.js

@@ -1,23 +1,11 @@
 /** 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 { evalNow, strengthAblation } from '../core/ablation.js';
 import { withWriteScope } from './busy.js';
-import { computeMass, computeCharge, computeTemperature, vecZero } from '../core/physics.js';
+import { computeMass, computeCharge, computeTemperature, initializeParticle } from '../core/physics.js';
 import { calculateStrength } from '../core/memory.js';
 import { DAY_MS } from '../util/time.js';
-// Float32Array <-> Buffer serialization
-export function float32ToBuffer(arr) {
-    const f32 = new Float32Array(arr);
-    return Buffer.from(f32.buffer);
-}
-export function bufferToFloat32(buf) {
-    if (buf.byteLength === 0 || buf.byteLength % 4 !== 0)
-        return [];
-    // Ensure we have a properly aligned copy (SQLite may return Uint8Array, not Buffer)
-    const bytes = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-    const aligned = new ArrayBuffer(bytes.length);
-    new Uint8Array(aligned).set(bytes);
-    return Array.from(new Float32Array(aligned));
-}
+import { placeholders } from '../util/sql.js';
+import { bufferToFloat32, float32ToBuffer } from '../util/vector-codec.js';
 // Schema migration
 /** Create the memory_physics table (migration v8). */
 export function createPhysicsTable(db) {
@@ -48,10 +36,10 @@ export function loadPhysicsState(db, memoryIds) {
         // Chunked so a whole-store candidate list stays under SQLite's bound-parameter limit.
         for (let i = 0; i < memoryIds.length; i += PHYSICS_ID_CHUNK) {
             const chunk = memoryIds.slice(i, i + PHYSICS_ID_CHUNK);
-            const placeholders = chunk.map(() => '?').join(',');
+            const marks = placeholders(chunk.length);
             // SAFETY: the SELECT projects exactly the PhysicsRow columns, in order.
             rows = rows.concat(db.prepare(`SELECT memory_id, position_blob, velocity_blob, mass, charge, temperature, last_simulation
-         FROM memory_physics WHERE memory_id IN (${placeholders})`).all(...chunk));
+         FROM memory_physics WHERE memory_id IN (${marks})`).all(...chunk));
         }
     }
     else {
@@ -97,20 +85,6 @@ export function savePhysicsState(db, particles) {
         }
     });
 }
-/** Initialize physics state for a memory from its embedding vector; returns the new particle without persisting (the caller must save). */
-export function initializeParticle(entry, embedding, now = evalNow()) {
-    const strength = calculateStrength(entry, now);
-    const ageDays = (now.getTime() - new Date(entry.created).getTime()) / DAY_MS;
-    return {
-        memoryId: entry.id,
-        position: [...embedding], // copy — position will diverge from original embedding
-        velocity: vecZero(embedding.length),
-        mass: computeMass(strength, entry.retrieval_count),
-        charge: computeCharge(entry.emotional_valence),
-        temperature: computeTemperature(ageDays, 1.0),
-        lastSimulation: now.toISOString(),
-    };
-}
 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. */
 export function resetAllPhysicsState(db, entries, embeddingIndex, now = evalNow()) {
@@ -141,7 +115,7 @@ export function refreshParticleProperties(particles, entries, now = evalNow()) {
         const entry = entries.get(p.memoryId);
         if (!entry)
             continue;
-        const strength = calculateStrength(entry, now);
+        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);

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

@@ -15,6 +15,7 @@ export declare class RequestStores implements RequestScope {
     readonly busyWaitMs: number | undefined;
     readonly requestId: string | undefined;
     readonly deadline: import("../util/request-scope.js").RequestDeadline | undefined;
+    readonly signal: AbortSignal | undefined;
     readonly setupDoneFor: string | undefined;
     constructor(opts?: RequestStoresOptions);
     get closed(): boolean;

package/dist/db/request-stores.js

@@ -1,7 +1,7 @@
 // One store handle per store for each request (HTTP call, MCP tool call, scoped CLI command), opened lazily and closed with it.
 import * as path from 'node:path';
 import { connectWithFacts, getHippoDbPath } from './connect.js';
-import { currentDeadline, currentRequestId, requestScopes } from '../util/request-scope.js';
+import { currentDeadline, currentRequestId, currentSignal, requestScopes } from '../util/request-scope.js';
 // Handles a scope owns, so closeHippoDb leaves them open for the rest of the request.
 const scopedHandles = new WeakSet();
 // process.exit skips every finally, so one exit listener closes the handles of scopes still open.
@@ -24,6 +24,7 @@ export class RequestStores {
     // Taken from the scope this one opens inside, so the request's log lines keep their id.
     requestId = currentRequestId();
     deadline = currentDeadline();
+    signal = currentSignal();
     setupDoneFor;
     #failFastWhenBusy;
     #handles = new Map();

package/dist/db/tables.d.ts

@@ -7,5 +7,7 @@ export declare function tableExists(db: DatabaseSyncLike, tableName: string): bo
 export declare function listTableNames(db: DatabaseSyncLike): string[];
 /** Row count of one table; null when the table is missing or unreadable, which callers show as unknown. */
 export declare function countTableRows(db: DatabaseSyncLike, table: string): number | null;
+/** Sleep runs a store keeps; stats.json lists exactly these, so a recall's stats rewrite reads a fixed number of rows. */
+export declare const CONSOLIDATION_RUNS_KEPT = 50;
 export declare function pruneConsolidationRuns(db: DatabaseSyncLike, keep?: number): void;
 //# sourceMappingURL=tables.d.ts.map

package/dist/db/tables.js

@@ -1,3 +1,4 @@
+import { errorCode, log } from '../util/log.js';
 /** Column names of one table; empty when the table is missing. */
 export function tableColumns(db, tableName) {
     if (!/^[a-z_]+$/i.test(tableName))
@@ -30,12 +31,15 @@ export function countTableRows(db, table) {
         const row = db.prepare(`SELECT COUNT(*) AS n FROM "${table.replace(/"/g, '""')}"`).get();
         return Number(row?.n ?? 0);
     }
-    catch {
+    catch (err) {
         // Callers treat an uncountable table as unknown; the bundle and doctor still finish.
+        log.warn(`could not count rows in table ${table}`, { table, code: errorCode(err) || 'unknown' });
         return null;
     }
 }
-export function pruneConsolidationRuns(db, keep = 50) {
+/** Sleep runs a store keeps; stats.json lists exactly these, so a recall's stats rewrite reads a fixed number of rows. */
+export const CONSOLIDATION_RUNS_KEPT = 50;
+export function pruneConsolidationRuns(db, keep = CONSOLIDATION_RUNS_KEPT) {
     db.prepare(`
     DELETE FROM consolidation_runs
     WHERE id NOT IN (

package/dist/db/vector-store.js

@@ -2,7 +2,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { withWriteScope } from './busy.js';
-import { log } from '../util/log.js';
+import { errorCode, errorFields, log } from '../util/log.js';
+import { placeholders } from '../util/sql.js';
 /** Legacy whole-file index; imported once into `memory_vectors`, then kept beside the store as a renamed backup. */
 const LEGACY_EMBEDDINGS_FILE = 'embeddings.json';
 export const EMBEDDING_MODEL_META_KEY = 'embedding_model';
@@ -66,7 +67,7 @@ function eachStoredVector(db, ids, take) {
     const unique = [...new Set(ids)];
     for (let i = 0; i < unique.length; i += ID_CHUNK) {
         const chunk = unique.slice(i, i + ID_CHUNK);
-        read(db.prepare(`SELECT memory_id, vector FROM memory_vectors WHERE memory_id IN (${chunk.map(() => '?').join(', ')})`).all(...chunk));
+        read(db.prepare(`SELECT memory_id, vector FROM memory_vectors WHERE memory_id IN (${placeholders(chunk.length)})`).all(...chunk));
     }
 }
 /** Vectors for `ids`, or every stored vector when `ids` is omitted. */
@@ -188,17 +189,30 @@ function insertSorted(top, m, k) {
 function stamp() {
     return `${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
 }
-/** Rename `fp` to `aside`; a rename blocked by an open handle (Windows) falls back to a copy, so the bytes are kept either way. */
+// The codes a rename gets when another process holds the file open (Windows); any other failure would fail a copy too.
+const RENAME_BLOCKED_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
+/** Rename `fp` to `aside`; a rename blocked by an open handle falls back to a copy, so the bytes are kept either way. */
 function moveAside(fp, aside) {
     try {
         fs.renameSync(fp, aside);
         return true;
     }
     catch (err) {
-        if (err instanceof Error && 'code' in err && err.code === 'ENOENT')
+        const code = errorCode(err);
+        if (code === 'ENOENT')
             return false;
+        if (!RENAME_BLOCKED_CODES.has(code))
+            throw err;
+        log.warn(`could not rename ${path.basename(fp)} aside (${code}); copying it instead`, { path: fp, ...errorFields(err) });
         fs.copyFileSync(fp, aside, fs.constants.COPYFILE_EXCL);
-        fs.rmSync(fp, { force: true });
+        try {
+            fs.rmSync(fp, { force: true });
+        }
+        catch (rmErr) {
+            // The original stays for the next open to retry, so a copy left beside it would pile up one per open.
+            fs.rmSync(aside, { force: true });
+            throw rmErr;
+        }
         return true;
     }
 }

package/dist/db/wal-checkpointer.js

@@ -2,6 +2,7 @@
 import * as path from 'node:path';
 import { Worker } from 'node:worker_threads';
 import { errorMessage, log } from '../util/log.js';
+import { DEFAULT_BUSY_WAIT_MS } from './busy.js';
 // WAL pages at which a connection checkpoints inside its own commit.
 const INLINE_CHECKPOINT_PAGES = 100;
 // The same limit while a worker checkpoints the store: SQLite still bounds the WAL when the worker falls behind.
@@ -17,7 +18,7 @@ const WORKER_SOURCE = `
 const { parentPort, workerData } = require('node:worker_threads');
 const { DatabaseSync } = require('node:sqlite');
 const db = new DatabaseSync(workerData.dbPath);
-db.exec('PRAGMA busy_timeout = 5000');
+db.exec('PRAGMA busy_timeout = ${DEFAULT_BUSY_WAIT_MS}');
 db.exec('PRAGMA synchronous = NORMAL');
 const pass = db.prepare('PRAGMA wal_checkpoint(PASSIVE)');
 parentPort.on('message', (message) => {

package/dist/doctor.d.ts

@@ -1,3 +1,4 @@
+import { type SpoolFs } from './capture/compaction-spool.js';
 /** Outcome of one check. `fail` makes `hippo doctor` exit 1. */
 export type DoctorStatus = 'pass' | 'warn' | 'fail' | 'info';
 /** One check in a {@link DoctorReport}. */
@@ -24,6 +25,8 @@ export interface DoctorOpts {
     version: string;
     nodeVersion?: string;
     now?: Date;
+    /** Stands in for the fs the spool check reads; a test makes one call fail. */
+    spoolFs?: SpoolFs;
 }
 /** Minimum Node.js version hippo supports (package.json engines). */
 export declare const MIN_NODE = "22.16.0";