hippo-memory 2.0.0 → 2.1.0

package/dist/db/request-stores.js

@@ -1,7 +1,8 @@
-// One store handle per store for each request (HTTP call, MCP tool call, scoped CLI command), opened lazily and closed with it.
+// 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, currentSignal, 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.
@@ -79,7 +80,10 @@ export class RequestStores {
         this.#handles.clear();
     }
 }
-/** 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 async function runWithRequestStores(fn, opts) {
     const outer = currentRequestStores();
     if (outer && !outer.closed)
@@ -94,7 +98,9 @@ export async function runWithRequestStores(fn, opts) {
         }
     });
 }
-/** 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 function withRequestStoresSync(fn) {
     const outer = currentRequestStores();
     if (outer && !outer.closed)
@@ -112,7 +118,10 @@ export function currentRequestStores() {
     const scope = requestScopes.getStore();
     return scope instanceof RequestStores ? scope : 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 function outsideRequestStores(fn) {
     return requestScopes.run({ requestId: currentRequestId() }, fn);
 }

package/dist/db/tables.d.ts

@@ -7,7 +7,8 @@ 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. */
+/** 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,4 +1,4 @@
-import { errorCode, log } from '../util/log.js';
+import { errorCode, log, errorFields } 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))
@@ -21,7 +21,10 @@ export function tableExists(db, tableName) {
 /** Names of the real tables, without sqlite internals and FTS virtual tables. */
 export function listTableNames(db) {
     // SAFETY: each row's shape matches the single `name` column named in the SELECT below.
-    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();
+    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);
 }
 /** Row count of one table; null when the table is missing or unreadable, which callers show as unknown. */
@@ -33,11 +36,16 @@ export function countTableRows(db, table) {
     }
     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' });
+        log.warn(`could not count rows in table ${table}`, {
+            table,
+            code: errorCode(err) || 'unknown',
+            ...errorFields(err),
+        });
         return null;
     }
 }
-/** Sleep runs a store keeps; stats.json lists exactly these, so a recall's stats rewrite reads a fixed number of rows. */
+/** 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(`

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

@@ -1,4 +1,7 @@
-/** Embedding vectors in the `memory_vectors` table: one Float32 BLOB per memory id, plus the one-time import of the old JSON index. */
+/**
+ * Embedding vectors in the `memory_vectors` table: one Float32 BLOB per memory id, plus the one-time import of the old
+ * JSON index.
+ */
 import type { DatabaseSyncLike } from './index.js';
 export declare const EMBEDDING_MODEL_META_KEY = "embedding_model";
 export declare const MEMORY_VECTORS_DDL = "\n  CREATE TABLE IF NOT EXISTS memory_vectors (\n    memory_id TEXT PRIMARY KEY,\n    model     TEXT NOT NULL,\n    dim       INTEGER NOT NULL,\n    vector    BLOB NOT NULL\n  );\n  CREATE TRIGGER IF NOT EXISTS trg_memory_vectors_delete AFTER DELETE ON memories BEGIN\n    DELETE FROM memory_vectors WHERE memory_id = old.id;\n  END;\n";
@@ -27,13 +30,19 @@ export interface VectorRow {
     readonly id: string;
     readonly vector: Float32Array;
 }
-/** The `k` rows closest to `query` by cosine, best first; ties go to the smaller id, so row order never changes the top k.
- *  The query rounds to Float32 as stored vectors are, and scores add up in float64, so every store that feeds it the same bytes ranks alike. */
+/**
+ * The `k` rows closest to `query` by cosine, best first; ties go to the smaller id, so row order never changes the top
+ * k.
+ * The query rounds to Float32 as stored vectors are, and scores add up in float64, so every store that feeds it the
+ * same bytes ranks alike.
+ */
 export declare function rankVectorRows(query: readonly number[], rows: Iterable<VectorRow>, k: number): VectorMatch[];
 /** The `k` stored vectors closest to `query` among `memories m` rows passing `where` (SQL starting with ` AND`).
  *  Filters run before the cut, so rows a caller may not see can never push admitted rows out of the top k. */
 export declare function topVectorMatches(db: DatabaseSyncLike, query: readonly number[], k: number, where: string, params: readonly (string | number)[]): Promise<VectorMatch[]>;
 /** Move a legacy `embeddings.json` into `memory_vectors`, then keep the file as `embeddings.json.imported-<stamp>`.
- *  Runs after the migration commits, so the rename never outlives rolled-back rows; a file an older binary writes later imports the same way. */
+ * Runs after the migration commits, so the rename never outlives rolled-back rows; a file an older binary writes later
+ * imports the same way.
+ */
 export declare function importLegacyEmbeddingIndex(db: DatabaseSyncLike, hippoRoot: string): void;
 //# sourceMappingURL=vector-store.d.ts.map

package/dist/db/vector-store.js

@@ -1,4 +1,7 @@
-/** Embedding vectors in the `memory_vectors` table: one Float32 BLOB per memory id, plus the one-time import of the old JSON index. */
+/**
+ * Embedding vectors in the `memory_vectors` table: one Float32 BLOB per memory id, plus the one-time import of the old
+ * JSON index.
+ */
 import * as fs from 'fs';
 import * as path from 'path';
 import { withWriteScope } from './busy.js';
@@ -57,8 +60,9 @@ export function deleteOrphanVectors(db) {
 function eachStoredVector(db, ids, take) {
     const read = (rows) => {
         // SAFETY: both SELECTs below name exactly these two columns; node:sqlite returns BLOBs as Uint8Array.
-        for (const row of rows)
+        for (const row of rows) {
             take(row.memory_id, decodeVector(row.vector));
+        }
     };
     if (ids === undefined) {
         read(db.prepare('SELECT memory_id, vector FROM memory_vectors').iterate());
@@ -67,7 +71,9 @@ 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 (${placeholders(chunk.length)})`).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. */
@@ -95,8 +101,12 @@ export function storedVectorDims(db) {
 export function hasStoredVectors(db) {
     return db.prepare('SELECT 1 FROM memory_vectors LIMIT 1').get() !== undefined;
 }
-/** The `k` rows closest to `query` by cosine, best first; ties go to the smaller id, so row order never changes the top k.
- *  The query rounds to Float32 as stored vectors are, and scores add up in float64, so every store that feeds it the same bytes ranks alike. */
+/**
+ * The `k` rows closest to `query` by cosine, best first; ties go to the smaller id, so row order never changes the top
+ * k.
+ * The query rounds to Float32 as stored vectors are, and scores add up in float64, so every store that feeds it the
+ * same bytes ranks alike.
+ */
 export function rankVectorRows(query, rows, k) {
     const best = bestMatches(query, k);
     if (!best)
@@ -191,7 +201,9 @@ function stamp() {
 }
 // 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. */
+/**
+ * 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);
@@ -203,7 +215,10 @@ function moveAside(fp, aside) {
             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) });
+        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);
         try {
             fs.rmSync(fp, { force: true });
@@ -216,7 +231,8 @@ function moveAside(fp, aside) {
         return true;
     }
 }
-// The old writer only wrote a plain object of id to number[]; any other shape is corrupt, and non-numeric entries are dropped.
+// The old writer only wrote a plain object of id to number[]; any other shape is corrupt, and non-numeric entries are
+// dropped.
 function parseLegacyIndex(raw) {
     let parsed;
     try {
@@ -235,7 +251,9 @@ function parseLegacyIndex(raw) {
     return index;
 }
 /** Move a legacy `embeddings.json` into `memory_vectors`, then keep the file as `embeddings.json.imported-<stamp>`.
- *  Runs after the migration commits, so the rename never outlives rolled-back rows; a file an older binary writes later imports the same way. */
+ * Runs after the migration commits, so the rename never outlives rolled-back rows; a file an older binary writes later
+ * imports the same way.
+ */
 export function importLegacyEmbeddingIndex(db, hippoRoot) {
     const fp = path.join(hippoRoot, LEGACY_EMBEDDINGS_FILE);
     let raw;
@@ -252,17 +270,19 @@ export function importLegacyEmbeddingIndex(db, hippoRoot) {
         const aside = `${fp}.corrupt-${stamp()}`;
         if (!moveAside(fp, aside))
             return;
-        log.error(`${LEGACY_EMBEDDINGS_FILE} could not be parsed; kept it as ${path.basename(aside)} and the next embed rebuilds the index`, { hippoRoot });
-        db.prepare(`INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`)
-            .run(EMBEDDING_MODEL_META_KEY, QUARANTINED_INDEX_IDENTITY);
+        log.error(`${LEGACY_EMBEDDINGS_FILE} could not be parsed; kept it as ${path.basename(aside)} and the next embed rebuilds ` +
+            `the index`, { hippoRoot });
+        db.prepare(`INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(EMBEDDING_MODEL_META_KEY, QUARANTINED_INDEX_IDENTITY);
         return;
     }
     // SAFETY: the SELECT names exactly the one column read.
-    const model = db.prepare(`SELECT value FROM meta WHERE key = ?`).get(EMBEDDING_MODEL_META_KEY)?.value ?? '';
+    const model = db.prepare(`SELECT value FROM meta WHERE key = ?`).get(EMBEDDING_MODEL_META_KEY)
+        ?.value ?? '';
     const written = withWriteScope(db, 'import_legacy_vectors', () => upsertVectors(db, index, model));
     const backup = `${fp}.imported-${stamp()}`;
     if (moveAside(fp, backup)) {
-        log.info(`moved ${written} vectors from ${LEGACY_EMBEDDINGS_FILE} into the store; the file is kept as ${path.basename(backup)}`, { hippoRoot });
+        log.info(`moved ${written} vectors from ${LEGACY_EMBEDDINGS_FILE} into the store; the file is kept as ` +
+            `${path.basename(backup)}`, { hippoRoot });
     }
 }
 //# sourceMappingURL=vector-store.js.map

package/dist/db/wal-checkpointer.d.ts

@@ -6,6 +6,7 @@ export interface WalCheckpointer {
 }
 /** The wal_autocheckpoint value for a new connection to `dbPath` in this process. */
 export declare function autoCheckpointPages(dbPath: string): number;
-/** Checkpoints `dbPath` off the calling thread until `stop()`; the worker starts with the first checkpoint that is due. */
+/** Checkpoints `dbPath` off the calling thread until `stop()`;
+ * the worker starts with the first checkpoint that is due. */
 export declare function startWalCheckpointer(dbPath: string): WalCheckpointer;
 //# sourceMappingURL=wal-checkpointer.d.ts.map

package/dist/db/wal-checkpointer.js

@@ -1,7 +1,8 @@
-// A served store's WAL is checkpointed on a worker thread: the fsync calls of a checkpoint would otherwise stall every request on the event loop.
+// A served store's WAL is checkpointed on a worker thread: the fsync calls of a checkpoint would otherwise stall every
+// request on the event loop.
 import * as path from 'node:path';
 import { Worker } from 'node:worker_threads';
-import { errorMessage, log } from '../util/log.js';
+import { errorFields, 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;
@@ -43,7 +44,19 @@ const backgrounded = new Set();
 export function autoCheckpointPages(dbPath) {
     return backgrounded.has(path.resolve(dbPath)) ? BACKSTOP_CHECKPOINT_PAGES : INLINE_CHECKPOINT_PAGES;
 }
-/** Checkpoints `dbPath` off the calling thread until `stop()`; the worker starts with the first checkpoint that is due. */
+/** An explicit execArgv keeps the parent's loaders out of the
+ * worker and silences its repeat of the node:sqlite warning. */
+function newCheckpointWorker(key) {
+    const started = new Worker(WORKER_SOURCE, {
+        eval: true,
+        execArgv: ['--no-warnings'],
+        workerData: { dbPath: key, maxPasses: MAX_PASSES },
+    });
+    started.unref();
+    return started;
+}
+/** Checkpoints `dbPath` off the calling thread until `stop()`;
+ * the worker starts with the first checkpoint that is due. */
 export function startWalCheckpointer(dbPath) {
     const key = path.resolve(dbPath);
     let worker;
@@ -58,16 +71,15 @@ export function startWalCheckpointer(dbPath) {
         backgrounded.delete(key);
     };
     const spawn = () => {
-        // An explicit execArgv keeps the parent's loaders out of the worker and silences its repeat of the node:sqlite warning.
-        const started = new Worker(WORKER_SOURCE, { eval: true, execArgv: ['--no-warnings'], workerData: { dbPath: key, maxPasses: MAX_PASSES } });
-        started.unref();
+        const started = newCheckpointWorker(key);
         started.on('message', (settled) => {
             running = false;
             due = settled ? RESPONSES_PER_CHECKPOINT : RESPONSES_PER_RETRY;
         });
         started.on('error', (err) => {
             end();
-            log.warn(`background checkpoint of ${key} stopped (${errorMessage(err)}); each connection checkpoints inside its own commit again`);
+            log.warn(`background checkpoint of ${key} stopped (${errorMessage(err)}); ` +
+                `each connection checkpoints inside its own commit again`, errorFields(err));
         });
         exited = new Promise((resolve) => { started.once('exit', () => resolve()); });
         return started;

package/dist/doctor.d.ts

@@ -20,7 +20,10 @@ export interface DoctorReport {
 /** Inputs for {@link runDoctor}; defaults come from the process. */
 export interface DoctorOpts {
     cwd?: string;
-    /** Home directory used to find agent configuration (~/.claude unless CLAUDE_CONFIG_DIR is set, ~/.codex unless CODEX_HOME is). */
+    /**
+     * Home directory used to find agent configuration (~/.claude unless CLAUDE_CONFIG_DIR is set, ~/.codex unless
+     * CODEX_HOME is).
+     */
     home?: string;
     version: string;
     nodeVersion?: string;

package/dist/doctor.js

@@ -7,14 +7,14 @@ import { findHippoStoreDir, isInitialized } from './core/project-identity.js';
 import { getGlobalRoot } from './sharing/global-store.js';
 import { readStoreHealth } from './store/diagnostics.js';
 import { loadConfig } from './core/config.js';
-import { openHippoDbReadOnly, closeHippoDb, getCurrentSchemaVersion, IncompatibleBinaryError } from './db/index.js';
+import { getCurrentSchemaVersion, IncompatibleBinaryError, } from './db/index.js';
 import { REPLAY_AFTER_MS, TRANSCRIPT_FILL_WINDOW_MS } from './core/compaction-timing.js';
 import { SPOOL_DIR, spoolCounts } from './capture/compaction-spool.js';
 import { isEmbeddingAvailable } from './embeddings/local.js';
 import { CODEX_TRUST_LINE, isCodexPresent } from './hooks/shared.js';
 import { claudeConfigDir, codexHomeDir } from './util/agent-homes.js';
 import { planProjectRepair } from './sharing/project-merge.js';
-import { projectTagReads } from './store/project-tags.js';
+import { readProjectTags } from './store/project-tags.js';
 import { resolveTenantId } from './store/tenant.js';
 import { errorMessage, log } from './util/log.js';
 import { readJsonFile, isJsonObjectLiteral } from './util/json.js';
@@ -60,8 +60,9 @@ function codexCheck(home) {
         ['hippo compact-resume', 'resume after compaction'],
     ];
     const missing = codexHooks.filter(([marker]) => !text.includes(marker)).map(([, what]) => what);
-    if (missing.length === 0)
+    if (missing.length === 0) {
         return { id: 'codex', status: 'pass', detail: `Codex: hippo memory hooks installed. ${CODEX_TRUST_LINE}` };
+    }
     return {
         id: 'codex',
         status: 'warn',
@@ -76,14 +77,22 @@ const FAILURE_LOG_SCHEMA = 46;
 /** The failed-tool-call count over the last 7 days, or why it could not be read. */
 function failuresCheck(failures, schemaVersion) {
     if (failures.ok) {
-        return { id: 'failures', status: 'info', detail: `${failures.value} failed tool calls logged in 7 days (hippo failures for detail)` };
+        return {
+            id: 'failures',
+            status: 'info',
+            detail: `${failures.value} failed tool calls logged in 7 days (hippo failures for detail)`,
+        };
     }
     if (!failures.message.includes('no such table')) {
         return { id: 'failures', status: 'warn', detail: `cannot read the failure log: ${failures.message}` };
     }
     return schemaVersion < FAILURE_LOG_SCHEMA
         ? { id: 'failures', status: 'info', detail: 'no failure log yet (hippo creates it on the next write)' }
-        : { id: 'failures', status: 'warn', detail: 'the failure_log table is missing, so failed tool calls are not being logged' };
+        : {
+            id: 'failures',
+            status: 'warn',
+            detail: 'the failure_log table is missing, so failed tool calls are not being logged',
+        };
 }
 /** How long ago the store last slept (consolidated), or why that history could not be read. */
 function sleepCheck(lastSleep, now) {
@@ -101,8 +110,17 @@ function sleepCheck(lastSleep, now) {
     }
     const days = Math.floor((now.getTime() - when) / DAY_MS);
     return days > 7
-        ? { id: 'sleep', status: 'warn', detail: `last sleep ${days} days ago`, fix: 'hippo sleep, and check the session-end hook is installed' }
-        : { id: 'sleep', status: 'pass', detail: `last sleep ${days === 0 ? 'today' : `${days} day${days === 1 ? '' : 's'} ago`}` };
+        ? {
+            id: 'sleep',
+            status: 'warn',
+            detail: `last sleep ${days} days ago`,
+            fix: 'hippo sleep, and check the session-end hook is installed',
+        }
+        : {
+            id: 'sleep',
+            status: 'pass',
+            detail: `last sleep ${days === 0 ? 'today' : `${days} day${days === 1 ? '' : 's'} ago`}`,
+        };
 }
 /** Spool counts in their own try, so a spool that cannot be read never hides the database counts. */
 function readSpool(store, now, spoolFs) {
@@ -113,11 +131,18 @@ function readSpool(store, now, spoolFs) {
         return { counts: { waiting: 0, stale: 0, bad: 0 }, unread: `; spool not read: ${errorMessage(err)}` };
     }
 }
-/** Compaction records the PostCompact hook left unfinished and spool files a replay has not finished, which `hippo sleep` replays. */
+/**
+ * Compaction records the PostCompact hook left unfinished and spool files a replay has not finished, which `hippo
+ * sleep` replays.
+ */
 function compactionsCheck(compactions, store, now, spoolFs) {
     if (!compactions.ok) {
         return compactions.message.includes('no such table')
-            ? { id: 'compactions', status: 'info', detail: 'no compaction records yet (hippo creates them on the next write)' }
+            ? {
+                id: 'compactions',
+                status: 'info',
+                detail: 'no compaction records yet (hippo creates them on the next write)',
+            }
             : { id: 'compactions', status: 'warn', detail: `cannot read the compaction records: ${compactions.message}` };
     }
     const { total, summarised, started } = compactions.value;
@@ -129,28 +154,37 @@ function compactionsCheck(compactions, store, now, spoolFs) {
         return { id: 'compactions', status: 'pass', detail: recorded };
     const fix = [
         stuck + spool.waiting + spool.stale > 0 ? 'hippo sleep   (replays them)' : '',
-        spool.bad > 0 ? `open the .bad files in ${path.join(store, SPOOL_DIR)}, save what you still need with hippo remember, then delete them` : '',
+        spool.bad > 0
+            ? `open the .bad files in ${path.join(store, SPOOL_DIR)}, save what you still need with hippo remember, then ` +
+                `delete them`
+            : '',
     ].filter((s) => s !== '');
     const unfinished = stuck === 0
         ? `${recorded} in the store`
         : `${stuck} compaction${stuck === 1 ? '' : 's'} unfinished after 10 minutes ` +
             `(${summarised} with a summary whose memories are not saved yet, ${started} with no summary yet)`;
-    const note = spooled ? `; spool: ${spool.waiting} waiting, ${spool.stale} left by a replay that stopped, ${spool.bad} .bad` : '';
+    const note = spooled
+        ? `; spool: ${spool.waiting} waiting, ${spool.stale} left by a replay that stopped, ${spool.bad} .bad`
+        : '';
     return { id: 'compactions', status: 'warn', detail: `${unfinished}${note}${unread}`, fix: fix.join('; ') };
 }
 /** Old project tags in the global store, counted by the repair's own plan so a truly user-global merge never warns. */
 function projectsCheck(globalRoot) {
-    let db = null;
     try {
-        db = openHippoDbReadOnly(globalRoot);
-        const r = planProjectRepair(projectTagReads(db, resolveTenantId({})), globalRoot);
+        const r = readProjectTags(globalRoot, resolveTenantId({}), (reads) => planProjectRepair(reads, globalRoot));
         const found = [
             r.copies.length > 0 ? `${r.copies.length} imported notes copied under the wrong project` : '',
-            r.folds.length > 0 ? `old project names that now resolve to another project: ${r.folds.map((f) => `${f.from} -> ${f.into}`).join(', ')}` : '',
+            r.folds.length > 0
+                ? `old project names that now resolve to another project: ` +
+                    `${r.folds.map((f) => `${f.from} -> ${f.into}`).join(', ')}`
+                : '',
             r.collisions.length > 0
-                ? `old project names shared by several projects, folded by hand only: ${r.collisions.map((c) => `${c.name} (${c.ids.join(', ')})`).join('; ')}`
+                ? `old project names shared by several projects, folded by hand only: ` +
+                    `${r.collisions.map((c) => `${c.name} (${c.ids.join(', ')})`).join('; ')}`
+                : '',
+            r.toProject.length + r.setAside.length > 0
+                ? `${r.toProject.length + r.setAside.length} merged memories tagged user-global`
                 : '',
-            r.toProject.length + r.setAside.length > 0 ? `${r.toProject.length + r.setAside.length} merged memories tagged user-global` : '',
         ].filter((s) => s !== '');
         return found.length === 0
             ? { id: 'projects', status: 'pass', detail: 'no duplicate or out-of-date project tags in the global store' }
@@ -164,22 +198,27 @@ function projectsCheck(globalRoot) {
     catch (err) {
         return { id: 'projects', status: 'info', detail: `project tags not checked (${errorMessage(err)})` };
     }
-    finally {
-        if (db !== null)
-            closeHippoDb(db);
-    }
 }
 function nodeCheck(node) {
     return versionAtLeast(node, MIN_NODE)
         ? { id: 'node', status: 'pass', detail: `Node.js ${node}` }
-        : { id: 'node', status: 'fail', detail: `Node.js ${node} is older than ${MIN_NODE}`, fix: `Install Node.js ${MIN_NODE} or newer` };
+        : {
+            id: 'node',
+            status: 'fail',
+            detail: `Node.js ${node} is older than ${MIN_NODE}`,
+            fix: `Install Node.js ${MIN_NODE} or newer`,
+        };
 }
 /** The store the checks run against (project first, then global), and the check that says which. */
 function storeCheck(local, globalRoot, hasGlobal) {
     if (local !== null && isInitialized(local)) {
         return {
             store: local,
-            check: { id: 'store', status: 'pass', detail: `project store at ${local}${hasGlobal ? ` (global store at ${globalRoot} too)` : ''}` }
+            check: {
+                id: 'store',
+                status: 'pass',
+                detail: `project store at ${local}${hasGlobal ? ` (global store at ${globalRoot} too)` : ''}`,
+            },
         };
     }
     if (local !== null) {
@@ -219,30 +258,49 @@ function schemaCheck(have, want) {
     return have === want
         ? { id: 'schema', status: 'pass', detail: `database schema v${have}` }
         : have > want
-            ? { id: 'schema', status: 'fail', detail: `database schema v${have} is newer than this hippo (v${want})`, fix: 'npm install -g hippo-memory@latest' }
-            : { id: 'schema', status: 'info', detail: `database schema v${have}; hippo migrates it to v${want} on the next write` };
+            ? {
+                id: 'schema',
+                status: 'fail',
+                detail: `database schema v${have} is newer than this hippo (v${want})`,
+                fix: 'npm install -g hippo-memory@latest',
+            }
+            : {
+                id: 'schema',
+                status: 'info',
+                detail: `database schema v${have}; hippo migrates it to v${want} on the next write`,
+            };
 }
 function memoriesCheck(memories, dormant) {
-    const memoryCheck = { id: 'memories', status: 'info', detail: `${memories ?? '?'} memories${dormant !== null ? `, ${dormant} dormant` : ''}` };
+    const memoryCheck = {
+        id: 'memories',
+        status: 'info',
+        detail: `${memories ?? '?'} memories${dormant !== null ? `, ${dormant} dormant` : ''}`,
+    };
     if (memories === 0) {
         memoryCheck.status = 'warn';
         memoryCheck.fix = 'hippo learn --git   (seed lessons from git history)';
     }
     return memoryCheck;
 }
-/** Whether the full-text index still matches `memories`; opening a current store no longer checks, so doctor reports and sleep repairs. */
+/**
+ * Whether the full-text index still matches `memories`; opening a current store no longer checks, so doctor reports and
+ * sleep repairs.
+ */
 function ftsCheck(fts) {
     if (!fts.ok)
         return { id: 'fts', status: 'warn', detail: `cannot read the full-text index: ${fts.message}` };
     const counts = fts.value;
-    if (counts === null)
+    if (counts === null) {
         return { id: 'fts', status: 'info', detail: 'no full-text index; search uses slower LIKE matching' };
-    if (counts.memories === counts.fts)
+    }
+    if (counts.memories === counts.fts) {
         return { id: 'fts', status: 'pass', detail: `full-text index in sync (${counts.fts} rows)` };
+    }
     return {
         id: 'fts',
         status: 'warn',
-        detail: `full-text index out of sync: ${counts.fts} indexed rows for ${counts.memories} memories, so search can miss memories or match removed ones`,
+        detail: `full-text index out of sync: ${counts.fts} indexed rows for ${counts.memories} memories, so search can ` +
+            `miss memories or match removed ones`,
         fix: 'hippo sleep   (re-syncs the index)',
     };
 }
@@ -270,12 +328,16 @@ function databaseChecks(store, now, spoolFs) {
         });
     }
     catch (err) {
-        return [{
+        return [
+            {
                 id: 'schema',
                 status: 'fail',
                 detail: `cannot open the database: ${errorMessage(err)}`,
-                fix: err instanceof IncompatibleBinaryError ? 'npm install -g hippo-memory@latest' : 'check file permissions on the .hippo folder',
-            }];
+                fix: err instanceof IncompatibleBinaryError
+                    ? 'npm install -g hippo-memory@latest'
+                    : 'check file permissions on the .hippo folder',
+            },
+        ];
     }
     return [
         schemaCheck(health.schemaVersion, getCurrentSchemaVersion()),
@@ -299,20 +361,37 @@ const CLAUDE_CODE_HOOKS = [
 function claudeCodeCheck(home) {
     const claudeDir = claudeConfigDir(home);
     if (!fs.existsSync(claudeDir)) {
-        return { id: 'claude-code', status: 'info', detail: 'Claude Code not found; other agents can use hippo over MCP (hippo mcp)' };
+        return {
+            id: 'claude-code',
+            status: 'info',
+            detail: 'Claude Code not found; other agents can use hippo over MCP (hippo mcp)',
+        };
     }
     const settings = readJson(path.join(claudeDir, 'settings.json'));
     const text = settings === null ? '' : JSON.stringify(settings);
     const viaPlugin = /hippo-memory@/.test(text);
     const missing = CLAUDE_CODE_HOOKS.filter(([marker]) => !text.includes(marker)).map(([, what]) => what);
     if (viaPlugin) {
-        return { id: 'claude-code', status: 'pass', detail: 'Claude Code: hippo plugin enabled (all hooks, including compaction and failed-tool capture)' };
+        return {
+            id: 'claude-code',
+            status: 'pass',
+            detail: 'Claude Code: hippo plugin enabled (all hooks, including compaction and failed-tool capture)',
+        };
     }
     if (missing.length === 0) {
-        return { id: 'claude-code', status: 'pass', detail: 'Claude Code: all hippo hooks installed, including compaction and failed-tool capture' };
+        return {
+            id: 'claude-code',
+            status: 'pass',
+            detail: 'Claude Code: all hippo hooks installed, including compaction and failed-tool capture',
+        };
     }
     if (missing.length === CLAUDE_CODE_HOOKS.length) {
-        return { id: 'claude-code', status: 'warn', detail: 'Claude Code found, but no hippo hooks are installed', fix: 'hippo hook install claude-code' };
+        return {
+            id: 'claude-code',
+            status: 'warn',
+            detail: 'Claude Code found, but no hippo hooks are installed',
+            fix: 'hippo hook install claude-code',
+        };
     }
     return {
         id: 'claude-code',
@@ -340,7 +419,8 @@ export function runDoctor(opts) {
         checks.push({
             id: 'pilot',
             status: 'info',
-            detail: `pilot holdout on: about ${holdoutRateBp / 100}% of sessions get no memories pushed by hippo (pilot.holdoutRateBp=${holdoutRateBp})`
+            detail: `pilot holdout on: about ${holdoutRateBp / 100}% of sessions get no memories pushed by hippo ` +
+                `(pilot.holdoutRateBp=${holdoutRateBp})`,
         });
     }
     if (hasGlobal)
@@ -351,7 +431,9 @@ export function runDoctor(opts) {
     checks.push({
         id: 'embeddings',
         status: 'info',
-        detail: isEmbeddingAvailable() ? 'local embeddings available (hybrid search)' : 'embeddings not installed; recall uses BM25 (optional: hippo embed --help)'
+        detail: isEmbeddingAvailable()
+            ? 'local embeddings available (hybrid search)'
+            : 'embeddings not installed; recall uses BM25 (optional: hippo embed --help)',
     });
     return { ok: !checks.some((c) => c.status === 'fail'), version: opts.version, store, checks };
 }