hippo-memory 1.69.0 → 1.71.0

package/dist/store/vector-index.d.ts

@@ -0,0 +1,46 @@
+import { type DatabaseSyncLike } from '../db/index.js';
+import type { MemoryEntry } from '../core/memory.js';
+import type { PhysicsParticle } from '../core/physics.js';
+import type { VectorBackfillQuery, VectorWrite, VectorWriteResult } from './port.js';
+/** What a store's vector index was built by: the stored identity, and whether any vector exists. */
+export interface EmbeddingIndexState {
+    readonly storedModel: string | null;
+    readonly hasVectors: boolean;
+}
+/** The model the index was built by: the stored identity, else the default model when vectors exist. */
+export declare function indexedModel(state: EmbeddingIndexState): string | null;
+/** Whether a vector write under the index identity `model` first drops the stored index, which another model built. */
+export declare function replacesIndex(state: EmbeddingIndexState, model: string): boolean;
+/** hippo.db's index state, the meta row and the EXISTS on one handle. */
+export declare function storedIndexState(hippoRoot: string): EmbeddingIndexState;
+/** Records `identity` as what built the index under `hippoRoot`. */
+export declare function saveIndexIdentity(hippoRoot: string, identity: string): void;
+/** Every stored vector keyed by memory id; `{}` when none. Search reads only the rows it ranks via `loadStoredVectors`. */
+export declare function loadEmbeddingIndex(hippoRoot: string): Record<string, number[]>;
+export interface StoredVectorSummary {
+    readonly ids: Set<string>;
+    readonly dims: number | undefined;
+}
+/** Every stored vector id and the float count of the first row, with no vector decoded. */
+export declare function storedVectorSummary(hippoRoot: string): StoredVectorSummary;
+/** Stored vectors for `ids` only. */
+export declare function loadStoredVectors(hippoRoot: string, ids: readonly string[]): Map<string, number[]>;
+/** `loadStoredVectors` as Float32 views, for a caller that only scores them. */
+export declare function loadStoredVectorViews(hippoRoot: string, ids: readonly string[]): Map<string, Float32Array>;
+/** Replace every stored vector with `index`; `model` defaults to the stored index identity. */
+export declare function saveEmbeddingIndex(hippoRoot: string, index: Record<string, number[]>, model?: string): void;
+/** Inserts or replaces `rows` under `model`, each row its own commit so a failure keeps the rows before it; returns how many it wrote. */
+export declare function saveStoredVectors(hippoRoot: string, rows: Iterable<readonly [string, readonly number[]]>, model: string): number;
+/** Drops the vectors of deleted memories under `hippoRoot`, then returns the ids that still have one. */
+export declare function pruneStoredVectors(hippoRoot: string): Set<string>;
+export declare function entriesWithoutVectorAt(db: DatabaseSyncLike, query: VectorBackfillQuery): MemoryEntry[];
+export declare function writeVectorsAt(db: DatabaseSyncLike, write: VectorWrite): VectorWriteResult;
+/** Every particle stored under `hippoRoot`. */
+export declare function loadStoredParticles(hippoRoot: string): PhysicsParticle[];
+/** Writes `particles` over their stored state under `hippoRoot`, as one batch. */
+export declare function saveStoredParticles(hippoRoot: string, particles: PhysicsParticle[]): void;
+/** Replaces every particle under `hippoRoot` with a fresh one per memory in `ids` that has an embedding; returns how many. Rows are read a page at a time. */
+export declare function resetStoredParticles(hippoRoot: string, ids: readonly string[], embeddingIndex: Record<string, number[]>): number;
+/** Stores a first particle for `entry`, placed at `vector`; a memory that has one keeps it. */
+export declare function seedStoredParticle(hippoRoot: string, entry: MemoryEntry, vector: number[]): void;
+//# sourceMappingURL=vector-index.d.ts.map

package/dist/store/vector-index.js

@@ -0,0 +1,170 @@
+// Owns hippo.db's stored vectors, the identity of the model that built them, and the particle rows: every read and write of the three.
+import { getMeta, setMeta, withWriteScope } from '../db/index.js';
+import { onHandle } from './open.js';
+import { DEFAULT_EMBEDDING_MODEL } from './embeddings/local.js';
+import { float32ToBuffer, initializeParticle, loadPhysicsState, resetAllPhysicsState, savePhysicsState } from '../db/physics-state.js';
+import { EMBEDDING_MODEL_META_KEY, deleteOrphanVectors, hasStoredVectors, loadVectors, loadVectorViews, replaceAllVectors, storedVectorDims, storedVectorIds, upsertVectors, } from '../db/vector-store.js';
+import { chunked, selectEntriesByIds } from './entry-reads.js';
+import { MEMORY_SELECT_COLUMNS, rowToEntry } from './rows.js';
+const MAX_BACKFILL_PAGE = 500;
+/** The model the index was built by: the stored identity, else the default model when vectors exist. */
+export function indexedModel(state) {
+    return state.storedModel ?? (state.hasVectors ? DEFAULT_EMBEDDING_MODEL : null);
+}
+/** Whether a vector write under the index identity `model` first drops the stored index, which another model built. */
+export function replacesIndex(state, model) {
+    const indexed = indexedModel(state);
+    return indexed !== null && indexed !== model;
+}
+function embeddingIndexStateOn(db) {
+    return {
+        storedModel: getMeta(db, EMBEDDING_MODEL_META_KEY, '').trim() || null,
+        hasVectors: hasStoredVectors(db),
+    };
+}
+/** hippo.db's index state, the meta row and the EXISTS on one handle. */
+export function storedIndexState(hippoRoot) {
+    return onHandle(hippoRoot, (db) => {
+        return embeddingIndexStateOn(db);
+    });
+}
+/** Records `identity` as what built the index under `hippoRoot`. */
+export function saveIndexIdentity(hippoRoot, identity) {
+    onHandle(hippoRoot, (db) => {
+        setMeta(db, EMBEDDING_MODEL_META_KEY, identity);
+    });
+}
+/** Every stored vector keyed by memory id; `{}` when none. Search reads only the rows it ranks via `loadStoredVectors`. */
+export function loadEmbeddingIndex(hippoRoot) {
+    return onHandle(hippoRoot, (db) => {
+        return Object.fromEntries(loadVectors(db));
+    });
+}
+/** Every stored vector id and the float count of the first row, with no vector decoded. */
+export function storedVectorSummary(hippoRoot) {
+    return onHandle(hippoRoot, (db) => {
+        return { ids: storedVectorIds(db), dims: storedVectorDims(db) };
+    });
+}
+/** Stored vectors for `ids` only. */
+export function loadStoredVectors(hippoRoot, ids) {
+    if (ids.length === 0)
+        return new Map();
+    return onHandle(hippoRoot, (db) => {
+        return loadVectors(db, ids);
+    });
+}
+/** `loadStoredVectors` as Float32 views, for a caller that only scores them. */
+export function loadStoredVectorViews(hippoRoot, ids) {
+    if (ids.length === 0)
+        return new Map();
+    return onHandle(hippoRoot, (db) => {
+        return loadVectorViews(db, ids);
+    });
+}
+/** Replace every stored vector with `index`; `model` defaults to the stored index identity. */
+export function saveEmbeddingIndex(hippoRoot, index, model) {
+    onHandle(hippoRoot, (db) => {
+        replaceAllVectors(db, index, model ?? getMeta(db, EMBEDDING_MODEL_META_KEY, ''));
+    });
+}
+/** Inserts or replaces `rows` under `model`, each row its own commit so a failure keeps the rows before it; returns how many it wrote. */
+export function saveStoredVectors(hippoRoot, rows, model) {
+    return onHandle(hippoRoot, (db) => {
+        return upsertVectors(db, rows, model);
+    });
+}
+/** Drops the vectors of deleted memories under `hippoRoot`, then returns the ids that still have one. */
+export function pruneStoredVectors(hippoRoot) {
+    return onHandle(hippoRoot, (db) => {
+        deleteOrphanVectors(db);
+        return storedVectorIds(db);
+    });
+}
+export function entriesWithoutVectorAt(db, query) {
+    if (!Number.isInteger(query.limit))
+        throw new RangeError('limit must be an integer');
+    const limit = Math.max(1, Math.min(query.limit, MAX_BACKFILL_PAGE));
+    const tenantClause = query.tenantId === undefined ? '' : ' AND tenant_id = ?';
+    const tenantArgs = query.tenantId === undefined ? [] : [query.tenantId];
+    // SAFETY: selects exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
+    const rows = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id > ?${tenantClause}
+       AND NOT EXISTS (SELECT 1 FROM memory_vectors v WHERE v.memory_id = memories.id AND v.model = ?)
+     ORDER BY id LIMIT ?`).all(query.afterId ?? '', ...tenantArgs, query.model, limit);
+    return rows.map(rowToEntry);
+}
+function ownedIds(db, ids, tenantId) {
+    const owned = new Set();
+    for (const chunk of chunked([...new Set(ids)])) {
+        // SAFETY: the SELECT names one column, id.
+        const rows = db.prepare(`SELECT id FROM memories WHERE +tenant_id = ? AND id IN (${chunk.map(() => '?').join(', ')})`).all(tenantId, ...chunk);
+        for (const row of rows)
+            owned.add(row.id);
+    }
+    return owned;
+}
+// savePhysicsState opens its own transaction and overwrites, so the first particle for a memory is inserted here instead.
+function insertNewParticles(db, rows) {
+    const stmt = db.prepare(`
+    INSERT INTO memory_physics (memory_id, position_blob, velocity_blob, mass, charge, temperature, last_simulation)
+    VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(memory_id) DO NOTHING
+  `);
+    for (const { memoryId, particle: p } of rows) {
+        if (p)
+            stmt.run(memoryId, float32ToBuffer(p.position), float32ToBuffer(p.velocity), p.mass, p.charge, p.temperature, p.lastSimulation);
+    }
+}
+export function writeVectorsAt(db, write) {
+    return withWriteScope(db, 'write_vectors', () => {
+        const replaces = replacesIndex(embeddingIndexStateOn(db), write.model);
+        if (replaces && !write.replaceIndex)
+            return { written: 0, modelMismatch: true };
+        const owned = ownedIds(db, write.rows.map((r) => r.memoryId), write.tenantId);
+        const rows = write.rows.filter((r) => owned.has(r.memoryId) && r.vector.length > 0 && r.vector.every(Number.isFinite));
+        if (rows.length === 0)
+            return { written: 0, modelMismatch: false };
+        if (replaces)
+            db.exec('DELETE FROM memory_vectors; DELETE FROM memory_physics;');
+        const written = upsertVectors(db, rows.map((r) => [r.memoryId, r.vector]), write.model);
+        insertNewParticles(db, rows);
+        setMeta(db, EMBEDDING_MODEL_META_KEY, write.model);
+        return { written, modelMismatch: false };
+    });
+}
+/** Every particle stored under `hippoRoot`. */
+export function loadStoredParticles(hippoRoot) {
+    return onHandle(hippoRoot, (db) => {
+        return Array.from(loadPhysicsState(db).values());
+    });
+}
+/** Writes `particles` over their stored state under `hippoRoot`, as one batch. */
+export function saveStoredParticles(hippoRoot, particles) {
+    onHandle(hippoRoot, (db) => {
+        savePhysicsState(db, particles);
+    });
+}
+const PARTICLE_PAGE = 64;
+function* entriesInPages(db, ids) {
+    for (const page of chunked(ids, PARTICLE_PAGE)) {
+        const rows = selectEntriesByIds(db, page);
+        for (const id of page) {
+            const entry = rows.get(id);
+            if (entry)
+                yield entry;
+        }
+    }
+}
+/** Replaces every particle under `hippoRoot` with a fresh one per memory in `ids` that has an embedding; returns how many. Rows are read a page at a time. */
+export function resetStoredParticles(hippoRoot, ids, embeddingIndex) {
+    return onHandle(hippoRoot, (db) => {
+        return resetAllPhysicsState(db, entriesInPages(db, ids), embeddingIndex);
+    });
+}
+/** Stores a first particle for `entry`, placed at `vector`; a memory that has one keeps it. */
+export function seedStoredParticle(hippoRoot, entry, vector) {
+    onHandle(hippoRoot, (db) => {
+        if (!loadPhysicsState(db, [entry.id]).has(entry.id))
+            savePhysicsState(db, [initializeParticle(entry, vector)]);
+    });
+}
+//# sourceMappingURL=vector-index.js.map

package/dist/{working-memory.d.ts → store/working-memory.d.ts}

@@ -1,11 +1,5 @@
-/**
- * Working Memory — bounded buffer for current-state notes.
- *
- * Separate from long-term semantic memory. Entries are scoped,
- * importance-ranked, and automatically evicted when the buffer
- * exceeds WM_MAX_ENTRIES per scope.
- */
-import type { JsonValue } from './json.js';
+/** Working Memory: bounded buffer for current-state notes, separate from long-term memory; scoped, importance-ranked, evicted past WM_MAX_ENTRIES per scope. */
+import type { JsonValue } from '../util/json.js';
 export declare const WM_MAX_ENTRIES = 20;
 export type JsonObject = {
     [key: string]: JsonValue;
@@ -21,12 +15,8 @@ export interface WorkingMemoryItem {
     createdAt: string;
     updatedAt: string;
 }
-/**
- * Push a new entry into working memory.
- * If the scope exceeds WM_MAX_ENTRIES, the lowest-importance entry
- * is evicted (ties broken by oldest created_at).
- * Returns the new row ID.
- */
+/** Push a new entry into working memory; past WM_MAX_ENTRIES the scope's lowest-importance entry is evicted (ties: oldest created_at). Returns the new
+ * row ID. */
 export declare function wmPush(hippoRoot: string, opts: {
     scope: string;
     content: string;
@@ -34,30 +24,25 @@ export declare function wmPush(hippoRoot: string, opts: {
     sessionId?: string;
     taskId?: string;
     metadata?: JsonObject;
+    tenantId?: string;
 }): number;
-/**
- * Read working memory entries, sorted by importance DESC.
- */
+/** Read working memory entries, sorted by importance DESC. */
 export declare function wmRead(hippoRoot: string, opts?: {
     scope?: string;
     sessionId?: string;
     limit?: number;
+    tenantId?: string;
 }): WorkingMemoryItem[];
-/**
- * Clear (delete) working memory entries. Returns the count deleted.
- */
+/** Clear (delete) working memory entries. Returns the count deleted. */
 export declare function wmClear(hippoRoot: string, opts?: {
     scope?: string;
     sessionId?: string;
+    tenantId?: string;
 }): number;
-/**
- * Flush working memory — delete entries after session end.
- * Functionally identical to wmClear but semantically distinct:
- * used at session boundaries to discard ephemeral state.
- * Returns the count flushed.
- */
+/** Flush working memory after session end: same as wmClear, but marks the session-boundary discard of ephemeral state. Returns the count flushed. */
 export declare function wmFlush(hippoRoot: string, opts?: {
     scope?: string;
     sessionId?: string;
+    tenantId?: string;
 }): number;
 //# sourceMappingURL=working-memory.d.ts.map

package/dist/store/working-memory.js

@@ -0,0 +1,118 @@
+/** Working Memory: bounded buffer for current-state notes, separate from long-term memory; scoped, importance-ranked, evicted past WM_MAX_ENTRIES per scope. */
+import { withWriteScope } from '../db/index.js';
+import { onHandle, openStore } from './open.js';
+import { warnDamagedColumn } from '../util/stored-json.js';
+import { resolveTenantId } from './tenant.js';
+export const WM_MAX_ENTRIES = 20;
+function rowToItem(row) {
+    let metadata = {};
+    try {
+        // SAFETY: metadata_json is always written by wmPush via JSON.stringify(opts.metadata ?? {}), so a successful parse yields a plain JSON object;
+        // malformed content falls through to the catch below.
+        metadata = JSON.parse(row.metadata_json);
+    }
+    catch {
+        // The item still lists with its content; only its metadata reads as empty.
+        warnDamagedColumn({ table: 'working_memory', id: row.id, column: 'metadata_json' }, 'not valid JSON');
+    }
+    return {
+        id: row.id,
+        scope: row.scope,
+        sessionId: row.session_id,
+        taskId: row.task_id,
+        importance: Number(row.importance),
+        content: row.content,
+        metadata,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/** Push a new entry into working memory; past WM_MAX_ENTRIES the scope's lowest-importance entry is evicted (ties: oldest created_at). Returns the new
+ * row ID. */
+export function wmPush(hippoRoot, opts) {
+    return onHandle(hippoRoot, (db) => {
+        const now = new Date().toISOString();
+        const importance = opts.importance ?? 0;
+        const tenantId = opts.tenantId ?? resolveTenantId({});
+        return withWriteScope(db, 'wm_push', () => {
+            const result = db.prepare(`
+        INSERT INTO working_memory(scope, session_id, task_id, importance, content, metadata_json, created_at, updated_at, tenant_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(opts.scope, opts.sessionId ?? null, opts.taskId ?? null, importance, opts.content, JSON.stringify(opts.metadata ?? {}), now, now, tenantId);
+            const id = Number(result.lastInsertRowid ?? 0);
+            evictOverCapacity(db, opts.scope, tenantId);
+            return id;
+        });
+    }, openStore);
+}
+function evictOverCapacity(db, scope, tenantId) {
+    // Evict if over capacity for this scope.
+    // SAFETY: `COUNT(*) AS cnt` always returns exactly one row { cnt }, so `.get()` never yields undefined.
+    const countRow = db.prepare(`
+    SELECT COUNT(*) AS cnt FROM working_memory WHERE scope = ? AND tenant_id = ?
+  `).get(scope, tenantId);
+    const count = Number(countRow?.cnt ?? 0);
+    if (count > WM_MAX_ENTRIES) {
+        const excess = count - WM_MAX_ENTRIES;
+        db.prepare(`
+      DELETE FROM working_memory
+      WHERE id IN (
+        SELECT id FROM working_memory
+        WHERE scope = ? AND tenant_id = ?
+        ORDER BY importance ASC, created_at ASC
+        LIMIT ?
+      )
+    `).run(scope, tenantId, excess);
+    }
+}
+/** Read working memory entries, sorted by importance DESC. */
+export function wmRead(hippoRoot, opts) {
+    return onHandle(hippoRoot, (db) => {
+        const clauses = ['tenant_id = ?'];
+        const params = [opts?.tenantId ?? resolveTenantId({})];
+        if (opts?.scope) {
+            clauses.push('scope = ?');
+            params.push(opts.scope);
+        }
+        if (opts?.sessionId) {
+            clauses.push('session_id = ?');
+            params.push(opts.sessionId);
+        }
+        const limit = Math.max(1, Math.trunc(opts?.limit ?? WM_MAX_ENTRIES));
+        params.push(limit);
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
+        // SAFETY: query selects exactly the columns of WorkingMemoryRow, in the
+        // same names, from the working_memory table this module owns.
+        const rows = db.prepare(`
+      SELECT id, scope, session_id, task_id, importance, content, metadata_json, created_at, updated_at
+      FROM working_memory
+      ${where}
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `).all(...params);
+        return rows.map(rowToItem);
+    }, openStore);
+}
+/** Clear (delete) working memory entries. Returns the count deleted. */
+export function wmClear(hippoRoot, opts) {
+    return onHandle(hippoRoot, (db) => {
+        const clauses = ['tenant_id = ?'];
+        const params = [opts?.tenantId ?? resolveTenantId({})];
+        if (opts?.scope) {
+            clauses.push('scope = ?');
+            params.push(opts.scope);
+        }
+        if (opts?.sessionId) {
+            clauses.push('session_id = ?');
+            params.push(opts.sessionId);
+        }
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
+        const result = db.prepare(`DELETE FROM working_memory ${where}`).run(...params);
+        return Number(result.changes ?? 0);
+    }, openStore);
+}
+/** Flush working memory after session end: same as wmClear, but marks the session-boundary discard of ephemeral state. Returns the count flushed. */
+export function wmFlush(hippoRoot, opts) {
+    return wmClear(hippoRoot, opts);
+}
+//# sourceMappingURL=working-memory.js.map

package/dist/{yaml.d.ts → store/yaml.d.ts}

@@ -1,8 +1,4 @@
-/**
- * Minimal YAML frontmatter serializer/deserializer.
- * No external deps. Handles simple key-value + arrays (inline only).
- * Sufficient for the MemoryEntry frontmatter schema.
- */
+/** Minimal YAML frontmatter serializer/deserializer with no external deps: simple key-value pairs and inline arrays, enough for the MemoryEntry schema. */
 type YamlValue = string | number | boolean | null | string[] | number[];
 export declare function dumpFrontmatter(obj: Record<string, YamlValue>): string;
 export interface ParsedFrontmatter {

package/dist/{yaml.js → store/yaml.js}

@@ -1,13 +1,9 @@
-/**
- * Minimal YAML frontmatter serializer/deserializer.
- * No external deps. Handles simple key-value + arrays (inline only).
- * Sufficient for the MemoryEntry frontmatter schema.
- */
+/** Minimal YAML frontmatter serializer/deserializer with no external deps: simple key-value pairs and inline arrays, enough for the MemoryEntry schema. */
 const SCALAR_LOOKALIKE = /^(null|true|false|-?\d+(\.\d+)?)$/;
 const UNESCAPES = new Map([['\\', '\\'], ['"', '"'], ['n', '\n'], ['r', '\r']]);
 function escapeString(s) {
     // A string that reads as null, a boolean or a number is quoted so it comes back a string.
-    if (/[:#\[\]{},\n\r"']/.test(s) || s.trim() !== s || s === '' || SCALAR_LOOKALIKE.test(s)) {
+    if (/[:#[\]{},\n\r"']/.test(s) || s.trim() !== s || s === '' || SCALAR_LOOKALIKE.test(s)) {
         const escaped = s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
         return `"${escaped}"`;
     }

package/dist/support-bundle.d.ts

@@ -1,5 +1,5 @@
 import { type DoctorOpts } from './doctor.js';
-import type { JsonObject } from './working-memory.js';
+import type { JsonObject } from './store/working-memory.js';
 export interface SupportBundleOpts extends DoctorOpts {
     readonly cwd: string;
     readonly home: string;

package/dist/support-bundle.js

@@ -1,24 +1,27 @@
-/** `hippo support-bundle`: one redacted JSON snapshot for a support ticket. Read-only (SQLite may leave empty -wal and -shm files); never touches memory content. */
-import { envByName, processEnv } from './env.js';
+/** `hippo support-bundle`: one redacted JSON snapshot for a support ticket. Read-only
+ * (SQLite may leave empty -wal and -shm files); never touches memory content. */
+import { envByName, processEnv } from './util/env.js';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { pathToFileURL } from 'url';
-import { findHippoStoreDir, isGlobalStoreRoot, realpathOrResolve } from './project-identity.js';
-import { getGlobalRoot } from './shared.js';
+import { findHippoStoreDir, isGlobalStoreRoot } from './core/project-identity.js';
+import { realpathOrResolve } from './util/real-path.js';
+import { getGlobalRoot } from './sharing/global-store.js';
 import { isInitialized } from './store/open.js';
-import { openHippoDbReadOnly, closeHippoDb, getSchemaVersion, getMeta, countTableRows } from './db.js';
+import { readStoreInventory } from './store/diagnostics.js';
 import { runDoctor } from './doctor.js';
-import { loadConfig } from './config.js';
-import { redactSecretsStrict } from './secret-detect.js';
-import { isJsonString } from './json.js';
-import { escapeRegex } from './escape.js';
+import { loadConfig } from './core/config.js';
+import { redactSecretsStrict } from './util/secret-detect.js';
+import { isJsonString, isJsonObject } from './util/json.js';
+import { escapeRegex } from './util/escape.js';
+import { errorMessage } from './util/log.js';
 const TAIL_MAX_BYTES = 256 * 1024;
 export const TAIL_MAX_LINES = 200;
 const TAIL_MAX_LINE_CHARS = 2000;
 // Greedy on purpose: complete key blocks are redacted first, so any END left is an orphan and what precedes it may be key body.
 const ORPHAN_KEY_END_RE = /^[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/;
-// The other env vars hippo reads outside the HIPPO_ prefix (src/embedding-provider.ts, connectors/*).
+// The other env vars hippo reads outside the HIPPO_ prefix (src/store/embeddings/provider.ts, connectors/*).
 const OTHER_ENV_NAMES = [
     'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'VOYAGE_API_KEY', 'COHERE_API_KEY', 'TYPESAFE_API_KEY',
     'GITHUB_TOKEN', 'GITHUB_WEBHOOK_SECRET', 'GITHUB_WEBHOOK_SECRET_PREVIOUS',
@@ -27,9 +30,6 @@ const OTHER_ENV_NAMES = [
     'XDG_DATA_HOME', 'MCP_SSE_HEARTBEAT_MS', 'MCP_SSE_MAX_AGE_SEC',
 ];
 const CONFIG_SECRET_KEY_RE = /key|token|secret|passw|credential|auth|cookie|bearer|signature|private/i;
-function isJsonObject(v) {
-    return typeof v === 'object' && v !== null && !Array.isArray(v);
-}
 function buildRuntime() {
     return {
         node: process.versions.node,
@@ -39,17 +39,6 @@ function buildRuntime() {
         osRelease: os.release(),
     };
 }
-function listTableNames(db) {
-    // SAFETY: each row's shape matches the single `name` column named in the SELECT above.
-    const rows = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND sql NOT LIKE 'CREATE VIRTUAL TABLE%' ORDER BY name`).all();
-    return rows.map((r) => r.name);
-}
-function countTables(db) {
-    const tables = {};
-    for (const name of listTableNames(db))
-        tables[name] = countTableRows(db, name);
-    return tables;
-}
 function redactConfigValue(value) {
     if (Array.isArray(value))
         return value.map(redactConfigValue);
@@ -88,21 +77,13 @@ function buildStoreEntry(kind, storeDir) {
     const walPath = `${dbPath}-wal`;
     if (fs.existsSync(walPath))
         files['hippo.db-wal'] = fs.statSync(walPath).size;
-    let db = null;
     try {
-        db = openHippoDbReadOnly(storeDir);
-        const schemaVersion = getSchemaVersion(db);
-        const minCompatibleBinary = getMeta(db, 'min_compatible_binary', '') || null;
-        const tables = countTables(db);
+        const { schemaVersion, minCompatibleBinary, tables } = readStoreInventory(storeDir);
         const { configFile, config } = readStoreConfig(storeDir);
         return { kind, path: storeDir, schemaVersion, minCompatibleBinary, files, tables, configFile, config };
     }
     catch (err) {
-        return { kind, path: storeDir, error: err instanceof Error ? err.message : String(err) };
-    }
-    finally {
-        if (db !== null)
-            closeHippoDb(db);
+        return { kind, path: storeDir, error: errorMessage(err) };
     }
 }
 function buildStores(opts) {
@@ -137,12 +118,13 @@ function listLogFileNames(dir) {
         .sort();
 }
 function tailLogFile(file) {
-    const size = fs.statSync(file).size;
-    const readSize = Math.min(size, TAIL_MAX_BYTES);
-    const startedMidFile = size > TAIL_MAX_BYTES;
     const fd = fs.openSync(file, 'r');
     let text;
+    let startedMidFile;
     try {
+        const size = fs.fstatSync(fd).size;
+        const readSize = Math.min(size, TAIL_MAX_BYTES);
+        startedMidFile = size > TAIL_MAX_BYTES;
         const buf = Buffer.alloc(readSize);
         fs.readSync(fd, buf, 0, readSize, size - readSize);
         text = buf.toString('utf8');

package/dist/{gated-write.d.ts → trust/gated-write.d.ts}

@@ -1,5 +1,5 @@
-import type { DatabaseSyncLike } from './db.js';
-import type { MemoryEntry } from './memory.js';
+import type { DatabaseSyncLike } from '../db/index.js';
+import type { MemoryEntry } from '../core/memory.js';
 export type GatedWriteResult = 'written' | 'skipped:not-worth-storing' | 'skipped:secret' | 'skipped:rejected';
 /** Runs on the caller's handle so it nests in the caller's transaction (writeEntry would open a second handle and wait on that lock); the caller mirrors after commit with an entry it stamped itself. The rejection audit lands inside that transaction, which is safe because a batch that rolls back stays `summarised` and replay writes the audit again. */
 export declare function gatedWrite(db: DatabaseSyncLike, hippoRoot: string, entry: MemoryEntry, opts?: {

package/dist/{gated-write.js → trust/gated-write.js}

@@ -1,10 +1,10 @@
 // The one write path for text no person typed into hippo: capture, compaction items and imported agent memories.
-import { isContentWorthStoring } from './memory-quality.js';
-import { RejectedValueError } from './rejection.js';
-import { detectSecret } from './secret-detect.js';
-import { auditRejectionRefusal } from './store/audit-event.js';
-import { stampOriginProject } from './store/entry-row.js';
-import { writeEntryDbOnly } from './store/entry-writes.js';
+import { isContentWorthStoring } from '../core/memory-quality.js';
+import { RejectedValueError } from '../store/rejection.js';
+import { detectSecret } from '../util/secret-detect.js';
+import { auditRejectionRefusal } from '../store/audit-event.js';
+import { stampOriginProject } from '../store/entry-row.js';
+import { writeEntryDbOnly } from '../store/entry-writes.js';
 /** Runs on the caller's handle so it nests in the caller's transaction (writeEntry would open a second handle and wait on that lock); the caller mirrors after commit with an entry it stamped itself. The rejection audit lands inside that transaction, which is safe because a batch that rolls back stays `summarised` and replay writes the audit again. */
 export function gatedWrite(db, hippoRoot, entry, opts) {
     // Off for imported agent memories: a person wrote those notes, and a one-line preference fails the check.

package/dist/trust/quarantine.d.ts

@@ -0,0 +1,4 @@
+/** Quarantine tier (CD5, AT3): pending/approved/rejected record for a memory `remember` flagged as untrusted. */
+export { quarantineScopeFor } from '../store/quarantine.js';
+export declare function isQuarantineScope(scope: string | null | undefined): boolean;
+//# sourceMappingURL=quarantine.d.ts.map

package/dist/trust/quarantine.js

@@ -0,0 +1,8 @@
+/** Quarantine tier (CD5, AT3): pending/approved/rejected record for a memory `remember` flagged as untrusted. */
+import { QUARANTINE_SCOPE_PREFIX } from '../store/quarantine.js';
+// The scope a held memory is stored under is the table's own rule, so the store module owns it.
+export { quarantineScopeFor } from '../store/quarantine.js';
+export function isQuarantineScope(scope) {
+    return scope != null && scope.startsWith(QUARANTINE_SCOPE_PREFIX);
+}
+//# sourceMappingURL=quarantine.js.map

package/dist/trust/reject-flow.d.ts

@@ -0,0 +1,23 @@
+import { type RejectedValueRow } from '../store/rejection.js';
+import { type AppliedRejection, type LiftedRejection } from '../store/rejected-values.js';
+export interface RejectFlowOpts {
+    hippoRoot: string;
+    tenantId: string;
+    actor: string;
+    reason: string;
+    /** By-id form: reject the CURRENT content of an existing memory. */
+    memoryId?: string;
+    /** Pre-emptive form: reject a value not currently stored (or already gone). */
+    value?: string;
+    /** The caller's own personal scope: the only personal rows the sweep may remove. Unset (the CLI) skips every personal row. */
+    ownScope?: string;
+}
+export type RejectFlowResult = AppliedRejection;
+/** `hippo reject` and `api.reject`: refuses a bad request, then tombstones the value and removes every row in reach that holds it. */
+export declare function rejectValue(opts: RejectFlowOpts): RejectFlowResult;
+export type UnrejectOutcome = LiftedRejection;
+/** `hippo unreject` and `api.unreject`: lifts the one tombstone a digest or prefix names. The only way to allow a rejected value again. */
+export declare function unrejectValue(hippoRoot: string, tenantId: string, digestOrPrefix: string, actor: string): UnrejectOutcome;
+/** `hippo rejections` / `api.listRejections` — list tombstones for a tenant. */
+export declare function listRejectionsForTenant(hippoRoot: string, tenantId: string): RejectedValueRow[];
+//# sourceMappingURL=reject-flow.d.ts.map