hippo-memory 1.60.0 → 1.62.0

package/dist/db/migrations/v45.js

@@ -0,0 +1,30 @@
+export const v45 = {
+    version: 45,
+    up: (db) => {
+        // Token ledger (src/token-ledger.ts, ROADMAP TE0): one row per block of
+        // memory text hippo hands an agent (hook, CLI, MCP, HTTP). `event` is 'inject'
+        // (sent), 'skip' (unchanged since the session's last inject, not sent), 'reset'
+        // (compaction dropped earlier injections, so the next one must be sent) or
+        // 'reread' (re-read by later calls, booked at session end per call day). block_hash
+        // lets the per-prompt hook skip an unchanged block. Rows older than the retention
+        // window are pruned on write. Additive only: no min_compatible_binary bump.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS token_ledger (
+          id         INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts         TEXT NOT NULL,
+          tenant_id  TEXT NOT NULL DEFAULT 'default',
+          session_id TEXT,
+          surface    TEXT NOT NULL,
+          event      TEXT NOT NULL,
+          items      INTEGER NOT NULL DEFAULT 0,
+          tokens     INTEGER NOT NULL DEFAULT 0,
+          block_hash TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_token_ledger_session
+          ON token_ledger(tenant_id, session_id, surface, id DESC);
+        CREATE INDEX IF NOT EXISTS idx_token_ledger_ts
+          ON token_ledger(ts);
+      `);
+    },
+};
+//# sourceMappingURL=v45.js.map

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

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

package/dist/db/migrations/v46.js

@@ -0,0 +1,25 @@
+export const v46 = {
+    version: 46,
+    up: (db) => {
+        // CD13 failure log (src/failure-log.ts): hashes only, since failure text can carry paths and secrets.
+        // Additive only: no min_compatible_binary bump.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS failure_log (
+          id          INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts          TEXT NOT NULL,
+          tenant_id   TEXT NOT NULL DEFAULT 'default',
+          session_id  TEXT,
+          tool        TEXT,
+          outcome     TEXT NOT NULL,
+          skip_rule   TEXT,
+          sig_hash    TEXT,
+          detail_hash TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_failure_log_tenant
+          ON failure_log(tenant_id, id);
+        CREATE INDEX IF NOT EXISTS idx_failure_log_ts
+          ON failure_log(ts);
+      `);
+    },
+};
+//# sourceMappingURL=v46.js.map

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

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

package/dist/db/migrations/v47.js

@@ -0,0 +1,17 @@
+export const v47 = {
+    version: 47,
+    up: (db) => {
+        // Scope grants (src/auth.ts, ROADMAP EI2): a member key reads a
+        // restricted scope only by an explicit row here. Additive only: no
+        // min_compatible_binary bump.
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS api_key_scope_grants (
+          key_id     TEXT NOT NULL,
+          scope      TEXT NOT NULL,
+          granted_at TEXT NOT NULL,
+          PRIMARY KEY(key_id, scope)
+        );
+      `);
+    },
+};
+//# sourceMappingURL=v47.js.map

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

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

package/dist/db/migrations/v48.js

@@ -0,0 +1,10 @@
+import { MEMORY_QUARANTINE_DDL } from '../continuity.js';
+export const v48 = {
+    version: 48,
+    up: (db) => {
+        // Quarantine (src/quarantine.ts, CD5): a poisoned or suspect memory sits here pending
+        // admin review instead of being hidden with no record. Additive only: no min_compatible_binary bump.
+        db.exec(MEMORY_QUARANTINE_DDL);
+    },
+};
+//# sourceMappingURL=v48.js.map

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

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

package/dist/db/migrations/v49.js

@@ -0,0 +1,31 @@
+export const v49 = {
+    version: 49,
+    up: (db) => {
+        // Compaction record (src/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 (
+          tenant_id       TEXT NOT NULL DEFAULT 'default',
+          id              TEXT NOT NULL,
+          session_id      TEXT NOT NULL,
+          origin_project  TEXT NOT NULL DEFAULT '',
+          compact_trigger TEXT,
+          cwd             TEXT,
+          transcript_path TEXT,
+          snapshot_saved  INTEGER NOT NULL DEFAULT 0,
+          started_at      TEXT NOT NULL,
+          summarised_at   TEXT,
+          summary         TEXT,
+          items_json      TEXT,
+          items_written   INTEGER NOT NULL DEFAULT 0,
+          status          TEXT NOT NULL DEFAULT 'started' CHECK (status IN ('started','summarised','done','no-summary')),
+          PRIMARY KEY (tenant_id, id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_compactions_session
+          ON compactions(tenant_id, session_id, started_at);
+        CREATE INDEX IF NOT EXISTS idx_compactions_status
+          ON compactions(tenant_id, status);
+      `);
+    },
+};
+//# sourceMappingURL=v49.js.map

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

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

package/dist/db/migrations/v50.js

@@ -0,0 +1,67 @@
+export const v50 = {
+    version: 50,
+    up: (db) => {
+        // Per-turn delivery events (src/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(`
+        CREATE TABLE IF NOT EXISTS delivery_events (
+          id                INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts                TEXT NOT NULL,
+          ledger_version    INTEGER NOT NULL,
+          tenant_id         TEXT NOT NULL DEFAULT 'default',
+          runtime           TEXT NOT NULL,
+          event_type        TEXT NOT NULL,
+          surface           TEXT NOT NULL,
+          store_hash        TEXT NOT NULL,
+          write_store       TEXT NOT NULL,
+          project_hash      TEXT,
+          session_id        TEXT,
+          session_state     TEXT NOT NULL,
+          host_turn_id      TEXT,
+          turn_seq          INTEGER,
+          duplicate_of      INTEGER,
+          prompt_hash       TEXT,
+          prompt_length     INTEGER NOT NULL DEFAULT 0,
+          query_hash        TEXT,
+          recall_trace_id   INTEGER,
+          block_state       TEXT NOT NULL,
+          prompt_recall     INTEGER NOT NULL DEFAULT 0,
+          considered_count  INTEGER NOT NULL DEFAULT 0,
+          filtered_count    INTEGER NOT NULL DEFAULT 0,
+          selected_count    INTEGER NOT NULL DEFAULT 0,
+          emitted_count     INTEGER NOT NULL DEFAULT 0,
+          rejected_count    INTEGER NOT NULL DEFAULT 0,
+          rejected_unlisted INTEGER NOT NULL DEFAULT 0,
+          sections_shown    INTEGER NOT NULL DEFAULT 0,
+          sections_dropped  INTEGER NOT NULL DEFAULT 0,
+          budget_tokens     INTEGER NOT NULL DEFAULT 0,
+          selected_tokens   INTEGER NOT NULL DEFAULT 0,
+          injected_tokens   INTEGER NOT NULL DEFAULT 0,
+          static_hash       TEXT,
+          recall_hash       TEXT,
+          emitted_hash      TEXT,
+          elapsed_ms        INTEGER NOT NULL DEFAULT 0
+        );
+        CREATE INDEX IF NOT EXISTS idx_delivery_events_session ON delivery_events(tenant_id, session_id, id);
+        CREATE INDEX IF NOT EXISTS idx_delivery_events_ts ON delivery_events(ts);
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_delivery_events_turn
+          ON delivery_events(tenant_id, session_id, event_type, turn_seq) WHERE turn_seq IS NOT NULL;
+
+        CREATE TABLE IF NOT EXISTS delivery_candidates (
+          event_id     INTEGER NOT NULL REFERENCES delivery_events(id) ON DELETE CASCADE,
+          tenant_id    TEXT NOT NULL DEFAULT 'default',
+          memory_id    TEXT NOT NULL,          -- no FK: events outlive forgotten memories, as recall traces do
+          source_store TEXT NOT NULL,
+          pool         TEXT NOT NULL,
+          stage        TEXT NOT NULL,
+          outcome      TEXT NOT NULL,
+          reason       TEXT,
+          cand_rank    INTEGER,
+          score        REAL,
+          tokens       INTEGER,
+          PRIMARY KEY (event_id, memory_id)
+        ) WITHOUT ROWID;
+      `);
+    },
+};
+//# sourceMappingURL=v50.js.map

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

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

package/dist/db/migrations/v51.js

@@ -0,0 +1,14 @@
+export const v51 = {
+    version: 51,
+    up: (db) => {
+        // Both indexes serve loadAmbientCandidates (src/store.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;
+        CREATE INDEX IF NOT EXISTS idx_memories_created_drift
+          ON memories(tenant_id) WHERE superseded_by IS NULL AND (length(created) <> 24 OR created NOT LIKE '%Z');
+      `);
+    },
+};
+//# sourceMappingURL=v51.js.map

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

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

package/dist/db/migrations/v52.js

@@ -0,0 +1,7 @@
+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.
+    up: (db) => db.exec(MEMORY_VECTORS_DDL),
+};
+//# sourceMappingURL=v52.js.map

package/dist/db/open.d.ts

@@ -0,0 +1,23 @@
+import { type DatabaseSyncLike } from './sqlite.js';
+export declare function getHippoDbPath(hippoRoot: string): string;
+/** 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;
+/** 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.
+ *  `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 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;
+/** Runs `fn` so that every store opened inside it, across awaits, waits at most `busyWaitMs` for a lock unless the open passes its own. */
+export declare function withBusyWait<T>(busyWaitMs: number, fn: () => T): T;
+/** `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?: {
+    busyWaitMs?: number;
+}): DatabaseSyncLike;
+/** 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;
+export declare function closeHippoDb(db: DatabaseSyncLike): void;
+//# sourceMappingURL=open.d.ts.map

package/dist/db/open.js

@@ -0,0 +1,146 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { cleanupArchivedMirrors } from '../raw-archive-mirror-cleanup.js';
+import { log } from '../log.js';
+import { DatabaseSync } from './sqlite.js';
+import { execWithBusyRetry } from './busy.js';
+import { tableExists } from './tables.js';
+import { assertBinaryCompatible, runMigrations } from './migrate.js';
+export function getHippoDbPath(hippoRoot) {
+    return path.join(hippoRoot, 'hippo.db');
+}
+// Hook commands run on every prompt, so inside withSharedStoreHandles each store pays its pragmas, migration check and mirror cleanup once.
+const sharedHandles = new Map();
+const sharedSet = new WeakSet();
+let shareDepth = 0;
+let shareBusyWaitMs;
+/** 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;
+/** 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}`);
+    // A lock held past one full wait belongs to a long transaction, so the hook's later writes skip at once.
+    for (const db of sharedHandles.values()) {
+        if (db.isOpen !== false)
+            db.exec('PRAGMA busy_timeout = 0');
+    }
+}
+function closeSharedStoreHandles() {
+    for (const db of sharedHandles.values()) {
+        sharedSet.delete(db);
+        if (db.isOpen !== false)
+            db.close();
+    }
+    sharedHandles.clear();
+}
+/** 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) {
+    if (shareDepth++ === 0) {
+        process.once('exit', closeSharedStoreHandles);
+        shareBusyWaitMs = opts?.busyWaitMs;
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        if (--shareDepth === 0) {
+            process.off('exit', closeSharedStoreHandles);
+            closeSharedStoreHandles();
+            shareBusyWaitMs = undefined;
+        }
+    }
+}
+/** 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;
+const scopedBusyWaitMs = new AsyncLocalStorage();
+/** Runs `fn` so that every store opened inside it, across awaits, waits at most `busyWaitMs` for a lock unless the open passes its own. */
+export function withBusyWait(busyWaitMs, fn) {
+    return scopedBusyWaitMs.run(busyWaitMs, fn);
+}
+/** `busyWaitMs` shortens every lock wait of this open, for a hook that must finish inside its own timeout. */
+export function openHippoDb(hippoRoot, opts) {
+    if (shareDepth === 0)
+        return openOwnHippoDb(hippoRoot, { busyWaitMs: opts?.busyWaitMs ?? scopedBusyWaitMs.getStore() });
+    const busyWaitMs = opts?.busyWaitMs ?? shareBusyWaitMs ?? scopedBusyWaitMs.getStore();
+    const key = `${path.resolve(getHippoDbPath(hippoRoot))}\0${busyWaitMs ?? ''}`;
+    const shared = sharedHandles.get(key);
+    if (shared?.isOpen && !shared.isTransaction)
+        return shared;
+    const db = openOwnHippoDb(hippoRoot, { busyWaitMs });
+    // An open nested inside a transaction gets its own connection, as it did before sharing.
+    if (!shared?.isOpen) {
+        sharedHandles.set(key, db);
+        sharedSet.add(db);
+    }
+    return db;
+}
+// Owner-only on create; SQLite gives the WAL and SHM files the db's mode. Existing paths keep theirs.
+function createStoreFilesOwnerOnly(hippoRoot) {
+    fs.mkdirSync(hippoRoot, { recursive: true, mode: 0o700 });
+    try {
+        fs.closeSync(fs.openSync(getHippoDbPath(hippoRoot), 'wx', 0o600));
+    }
+    catch (err) {
+        if (!(err instanceof Error && 'code' in err && err.code === 'EEXIST'))
+            throw err;
+    }
+}
+function openOwnHippoDb(hippoRoot, opts) {
+    createStoreFilesOwnerOnly(hippoRoot);
+    const db = new DatabaseSync(getHippoDbPath(hippoRoot));
+    const busyWaitMs = opts?.busyWaitMs;
+    try {
+        db.exec(`PRAGMA busy_timeout = ${busyWaitMs ?? 5000}`);
+        execWithBusyRetry(db, 'PRAGMA journal_mode = WAL', busyWaitMs);
+        db.exec('PRAGMA synchronous = NORMAL');
+        db.exec('PRAGMA wal_autocheckpoint = 100');
+        db.exec('PRAGMA foreign_keys = ON');
+        runMigrations(db, hippoRoot, busyWaitMs);
+        // Path A backfill: delete any orphan markdown mirrors for already-archived
+        // raw_archive rows. Idempotent via per-row raw_archive.mirror_cleaned_at
+        // (v21). Wrapped in try/catch — a filesystem failure must not prevent DB open.
+        try {
+            cleanupArchivedMirrors(hippoRoot, db);
+        }
+        catch (cleanupErr) {
+            log.error(`openHippoDb: cleanupArchivedMirrors failed (non-fatal): ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}`);
+        }
+        return db;
+    }
+    catch (error) {
+        try {
+            db.close();
+        }
+        catch {
+            // Best effort only.
+        }
+        throw error;
+    }
+}
+/** 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) {
+    const db = new DatabaseSync(getHippoDbPath(hippoRoot), { readOnly: true });
+    try {
+        db.exec('PRAGMA busy_timeout = 5000');
+        if (tableExists(db, 'meta'))
+            assertBinaryCompatible(db);
+        return db;
+    }
+    catch (error) {
+        try {
+            db.close();
+        }
+        catch {
+            // Best effort only.
+        }
+        throw error;
+    }
+}
+export function closeHippoDb(db) {
+    if (sharedSet.has(db))
+        return;
+    db.close();
+}
+//# sourceMappingURL=open.js.map

package/dist/db/sqlite.d.ts

@@ -0,0 +1,21 @@
+interface StatementSyncLike {
+    run(...params: unknown[]): {
+        lastInsertRowid?: number | bigint;
+        changes?: number;
+    };
+    get<T>(...params: unknown[]): T;
+    all(...params: unknown[]): unknown[];
+    iterate(...params: unknown[]): IterableIterator<unknown>;
+}
+export interface DatabaseSyncLike {
+    exec(sql: string): void;
+    prepare(sql: string): StatementSyncLike;
+    close(): void;
+    readonly isOpen?: boolean;
+    readonly isTransaction?: boolean;
+}
+declare const DatabaseSync: new (path: string, options?: {
+    readOnly?: boolean;
+}) => DatabaseSyncLike;
+export { DatabaseSync };
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/db/sqlite.js

@@ -0,0 +1,8 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+// SAFETY: node:sqlite's DatabaseSync constructor genuinely has this shape at
+// runtime (Node's built-in synchronous SQLite module); there are no bundled
+// types for it here, so this require + cast is the module's documented boundary.
+const { DatabaseSync } = require('node:sqlite');
+export { DatabaseSync };
+//# sourceMappingURL=sqlite.js.map

package/dist/db/tables.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseSyncLike } from './sqlite.js';
+export declare function tableHasColumn(db: DatabaseSyncLike, tableName: string, columnName: string): boolean;
+export declare function tableExists(db: DatabaseSyncLike, tableName: string): boolean;
+/** 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;
+export declare function pruneConsolidationRuns(db: DatabaseSyncLike, keep?: number): void;
+//# sourceMappingURL=tables.d.ts.map

package/dist/db/tables.js

@@ -0,0 +1,38 @@
+export function tableHasColumn(db, tableName, columnName) {
+    if (!/^[a-z_]+$/i.test(tableName))
+        throw new Error(`Invalid table name: ${tableName}`);
+    // SAFETY: rows' shape matches PRAGMA table_info's documented `name` column.
+    const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+    return rows.some((row) => row.name === columnName);
+}
+export function tableExists(db, tableName) {
+    if (!/^[a-z_]+$/i.test(tableName))
+        throw new Error(`Invalid table name: ${tableName}`);
+    // SAFETY: row's shape matches the single `name` column named in the
+    // SELECT above.
+    const row = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name = ?`).get(tableName);
+    return !!row?.name;
+}
+/** Row count of one table; null when the table is missing or unreadable, which callers show as unknown. */
+export function countTableRows(db, table) {
+    try {
+        // SAFETY: COUNT(*) returns one row with one numeric column.
+        const row = db.prepare(`SELECT COUNT(*) AS n FROM "${table.replace(/"/g, '""')}"`).get();
+        return Number(row?.n ?? 0);
+    }
+    catch {
+        // Callers treat an uncountable table as unknown; the bundle and doctor still finish.
+        return null;
+    }
+}
+export function pruneConsolidationRuns(db, keep = 50) {
+    db.prepare(`
+    DELETE FROM consolidation_runs
+    WHERE id NOT IN (
+      SELECT id FROM consolidation_runs
+      ORDER BY timestamp DESC, id DESC
+      LIMIT ?
+    )
+  `).run(keep);
+}
+//# sourceMappingURL=tables.js.map

package/dist/db.d.ts

@@ -1,47 +1,7 @@
-interface StatementSyncLike {
-    run(...params: unknown[]): {
-        lastInsertRowid?: number | bigint;
-        changes?: number;
-    };
-    get<T>(...params: unknown[]): T;
-    all(...params: unknown[]): unknown[];
-}
-export interface DatabaseSyncLike {
-    exec(sql: string): void;
-    prepare(sql: string): StatementSyncLike;
-    close(): void;
-    readonly isOpen?: boolean;
-    readonly isTransaction?: boolean;
-}
-export declare function getHippoDbPath(hippoRoot: string): string;
-export declare function getCurrentSchemaVersion(): number;
-/** Thrown by {@link assertBinaryCompatible}; doctor uses it to pick the upgrade fix over a generic permissions fix. */
-export declare class IncompatibleBinaryError extends Error {
-}
-export declare function isSqliteBusy(error: unknown): boolean;
-export declare function execWithBusyRetry(db: DatabaseSyncLike, sql: string, timeoutMs?: number): void;
-/** 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;
-/** 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.
- *  `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>;
-/** `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?: {
-    busyWaitMs?: number;
-}): DatabaseSyncLike;
-/** 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;
-export declare function getSchemaVersion(db: DatabaseSyncLike): number;
-export declare function closeHippoDb(db: DatabaseSyncLike): void;
-export declare function getMeta(db: DatabaseSyncLike, key: string, fallback?: string): string;
-export declare function setMeta(db: DatabaseSyncLike, key: string, value: string): void;
-/** 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;
-export declare function isFtsAvailable(db: DatabaseSyncLike): boolean;
-export declare function pruneConsolidationRuns(db: DatabaseSyncLike, keep?: number): void;
-export {};
+export type { DatabaseSyncLike } from './db/sqlite.js';
+export { isSqliteBusy, STORE_BUSY_MESSAGE, execWithBusyRetry } from './db/busy.js';
+export { getSchemaVersion, getMeta, setMeta, isFtsAvailable } from './db/meta.js';
+export { countTableRows, pruneConsolidationRuns } from './db/tables.js';
+export { getCurrentSchemaVersion, IncompatibleBinaryError } from './db/migrate.js';
+export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, withBusyWait, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './db/open.js';
 //# sourceMappingURL=db.d.ts.map