hippo-memory 1.61.0 → 1.63.0

package/dist/delivery-recorder.js

@@ -24,12 +24,7 @@ function byDepthThenScore(a, b) {
         return score;
     return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 }
-/** A recorder for one call; every observer method is guarded, and a throw marks it broken instead of escaping. */
-export function createDeliveryRecorder(init) {
-    const startedMs = Date.now();
-    const ts = evalNow().toISOString();
-    // Test-only fault injection, as HIPPO_FAKE_NOW is for time.
-    const fault = envTestDeliveryFault();
+function readPayload(init) {
     const payloadSession = hookPayloadSessionId(init.stdinText);
     const subagent = isSubagentPayload(init.stdinText);
     const envSession = init.envSessionId !== undefined && init.envSessionId !== '' ? init.envSessionId : null;
@@ -40,148 +35,127 @@ export function createDeliveryRecorder(init) {
     const sessionState = subagent
         ? 'subagent'
         : payloadSession !== null ? 'payload' : envSession !== null ? 'env' : 'missing';
-    const candidates = new Map();
-    const picked = new Map();
-    const filtered = new Set();
-    let facts = null;
-    let shown = 0;
-    let dropped = 0;
-    let disabledSeen = false;
-    let outcome = { state: 'empty' };
-    let broken = null;
-    let flushed = false;
-    const guard = (fn) => {
-        if (broken !== null)
-            return;
-        try {
-            if (fault === 'observe')
-                throw new Error('injected observe fault');
-            fn();
-        }
-        catch (error) {
-            broken = error instanceof Error ? error.message : String(error);
-        }
-    };
-    const rejectId = (id, stage, reason, score, tokens) => {
-        const held = candidates.get(id);
-        // First rejection wins; an id never offered is not a candidate of this call.
-        if (!held || held.reason !== null)
-            return;
-        candidates.set(id, { ...held, stage, reason, score, tokens });
-    };
-    const build = () => {
-        if (fault === 'build')
-            throw new Error('injected build fault');
-        const staticReused = outcome.staticReused === true;
-        const rows = [];
-        for (const p of picked.values()) {
-            const held = candidates.get(p.entry.id);
-            rows.push({
-                memoryId: p.entry.id,
-                sourceStore: p.sourceStore,
-                pool: p.promptRecall ? 'prompt-recall' : held?.pool === 'pin' || p.entry.pinned ? 'pin' : 'recent',
-                stage: 'final',
-                outcome: staticReused && !p.promptRecall ? 'reused' : 'emitted',
-                reason: null,
-                rank: p.rank,
-                score: p.score,
-                tokens: p.tokens,
-            });
-        }
-        const rejected = [];
-        let undecided = 0;
-        for (const c of candidates.values()) {
-            if (picked.has(c.id))
-                continue;
-            if (c.reason === null)
-                undecided += 1;
-            else
-                rejected.push(c);
-        }
-        rejected.sort(byDepthThenScore);
-        for (const c of rejected.slice(0, DELIVERY_REJECTED_ROW_CAP)) {
-            rows.push({
-                memoryId: c.id, sourceStore: c.sourceStore, pool: c.pool, stage: c.stage ?? 'load', outcome: 'rejected',
-                reason: c.reason, rank: null, score: c.score, tokens: c.tokens,
-            });
-        }
-        const overflow = Math.max(0, rejected.length - DELIVERY_REJECTED_ROW_CAP);
-        const emitted = outcome.emittedText ?? null;
-        return {
-            ts,
-            tenantId: init.tenantId,
-            runtime: hostTurnId !== null ? 'codex' : hookEvent !== null ? 'claude-code' : 'unknown',
-            eventType: hookEvent === 'UserPromptSubmit' ? 'prompt-submit' : 'pinned-manual',
-            surface: 'hook',
-            storeHash: init.storeHash,
-            writeStore: init.writeStore,
-            projectHash: facts !== null && facts.projectName !== '' ? blockHash(facts.projectName) : null,
-            sessionId: payloadSession ?? envSession,
-            sessionState,
-            hostTurnId,
-            promptHash: prompt !== null ? blockHash(prompt) : null,
-            promptLength: prompt?.length ?? 0,
-            queryHash: null,
-            recallTraceId: null,
-            blockState: disabledSeen ? 'disabled' : outcome.state,
-            promptRecall: facts?.promptRecall === true,
-            consideredCount: new Set([...candidates.keys(), ...picked.keys()]).size,
-            filteredCount: filtered.size,
-            selectedCount: picked.size,
-            emittedCount: rows.filter((r) => r.outcome === 'emitted').length,
-            rejectedCount: rejected.length + undecided,
-            rejectedUnlisted: overflow + undecided,
-            sectionsShown: shown,
-            sectionsDropped: dropped,
-            budgetTokens: facts?.budgetTokens ?? 0,
-            selectedTokens: [...picked.values()].reduce((sum, p) => sum + p.tokens, 0),
-            injectedTokens: emitted !== null ? estimateTokens(emitted) : 0,
-            staticHash: outcome.staticHash ?? null,
-            recallHash: outcome.recallHash ?? null,
-            emittedHash: emitted !== null ? blockHash(emitted) : null,
-            elapsedMs: Math.max(0, Date.now() - startedMs),
-            candidates: rows,
-        };
+    return { payloadSession, envSession, prompt, hostTurnId, hookEvent, sessionState };
+}
+function rejectId(state, id, stage, reason, score, tokens) {
+    const held = state.candidates.get(id);
+    // First rejection wins; an id never offered is not a candidate of this call.
+    if (!held || held.reason !== null)
+        return;
+    state.candidates.set(id, { ...held, stage, reason, score, tokens });
+}
+function pickedRows(state) {
+    const staticReused = state.outcome.staticReused === true;
+    const rows = [];
+    for (const p of state.picked.values()) {
+        const held = state.candidates.get(p.entry.id);
+        rows.push({
+            memoryId: p.entry.id,
+            sourceStore: p.sourceStore,
+            pool: p.promptRecall ? 'prompt-recall' : held?.pool === 'pin' || p.entry.pinned ? 'pin' : 'recent',
+            stage: 'final',
+            outcome: staticReused && !p.promptRecall ? 'reused' : 'emitted',
+            reason: null,
+            rank: p.rank,
+            score: p.score,
+            tokens: p.tokens,
+        });
+    }
+    return rows;
+}
+/** Rejected candidates deepest first, capped at DELIVERY_REJECTED_ROW_CAP rows. */
+function rejectedRows(state) {
+    const rejected = [];
+    let undecided = 0;
+    for (const c of state.candidates.values()) {
+        if (state.picked.has(c.id))
+            continue;
+        if (c.reason === null)
+            undecided += 1;
+        else
+            rejected.push(c);
+    }
+    rejected.sort(byDepthThenScore);
+    const rows = rejected.slice(0, DELIVERY_REJECTED_ROW_CAP).map((c) => ({
+        memoryId: c.id, sourceStore: c.sourceStore, pool: c.pool, stage: c.stage ?? 'load', outcome: 'rejected',
+        reason: c.reason, rank: null, score: c.score, tokens: c.tokens,
+    }));
+    const overflow = Math.max(0, rejected.length - DELIVERY_REJECTED_ROW_CAP);
+    return { rows, rejected: rejected.length, undecided, overflow };
+}
+function buildEvent(init, payload, state, ts, startedMs) {
+    const { facts, outcome } = state;
+    const picked = pickedRows(state);
+    const rejected = rejectedRows(state);
+    const rows = [...picked, ...rejected.rows];
+    const emitted = outcome.emittedText ?? null;
+    return {
+        ts,
+        tenantId: init.tenantId,
+        runtime: payload.hostTurnId !== null ? 'codex' : payload.hookEvent !== null ? 'claude-code' : 'unknown',
+        eventType: payload.hookEvent === 'UserPromptSubmit' ? 'prompt-submit' : 'pinned-manual',
+        surface: 'hook',
+        storeHash: init.storeHash,
+        writeStore: init.writeStore,
+        projectHash: facts !== null && facts.projectName !== '' ? blockHash(facts.projectName) : null,
+        sessionId: payload.payloadSession ?? payload.envSession,
+        sessionState: payload.sessionState,
+        hostTurnId: payload.hostTurnId,
+        promptHash: payload.prompt !== null ? blockHash(payload.prompt) : null,
+        promptLength: payload.prompt?.length ?? 0,
+        queryHash: null,
+        recallTraceId: null,
+        blockState: state.disabledSeen ? 'disabled' : outcome.state,
+        promptRecall: facts?.promptRecall === true,
+        consideredCount: new Set([...state.candidates.keys(), ...state.picked.keys()]).size,
+        filteredCount: state.filtered.size,
+        selectedCount: state.picked.size,
+        emittedCount: rows.filter((r) => r.outcome === 'emitted').length,
+        rejectedCount: rejected.rejected + rejected.undecided,
+        rejectedUnlisted: rejected.overflow + rejected.undecided,
+        sectionsShown: state.shown,
+        sectionsDropped: state.dropped,
+        budgetTokens: facts?.budgetTokens ?? 0,
+        selectedTokens: [...state.picked.values()].reduce((sum, p) => sum + p.tokens, 0),
+        injectedTokens: emitted !== null ? estimateTokens(emitted) : 0,
+        staticHash: outcome.staticHash ?? null,
+        recallHash: outcome.recallHash ?? null,
+        emittedHash: emitted !== null ? blockHash(emitted) : null,
+        elapsedMs: Math.max(0, Date.now() - startedMs),
+        candidates: rows,
     };
+}
+/** The candidate-tracking half of the observer, each method run through `guard`. */
+function candidateMethods(state, guard) {
     return {
-        root: init.root,
-        facts: (f) => guard(() => { facts = { ...f }; }),
-        sections: (s, d) => guard(() => { shown = s; dropped = d; }),
-        watchAdmit: (admit) => (e) => {
-            const ok = admit(e);
-            if (!ok)
-                guard(() => { filtered.add(e.id); });
-            return ok;
-        },
         qualityDropped: (e, isGlobal) => guard(() => {
-            filtered.add(e.id);
-            if (!candidates.has(e.id)) {
-                candidates.set(e.id, {
+            state.filtered.add(e.id);
+            if (!state.candidates.has(e.id)) {
+                state.candidates.set(e.id, {
                     id: e.id, sourceStore: storeOf(isGlobal), pool: 'recent', stage: null, reason: null, score: null, tokens: null,
                 });
             }
-            rejectId(e.id, 'load', 'quality', null, null);
+            rejectId(state, e.id, 'load', 'quality', null, null);
         }),
-        disabled: () => guard(() => { disabledSeen = true; }),
         offer: (entries, isGlobal, pool) => guard(() => {
             for (const e of entries) {
-                const held = candidates.get(e.id);
+                const held = state.candidates.get(e.id);
                 const wanted = pool ?? (e.pinned ? 'pin' : 'recent');
                 // A loaded recent row the prompt-recall gate then judges belongs to that pool.
                 const relabel = held !== undefined && held.reason === null && held.pool === 'recent' && wanted === 'prompt-recall';
                 if (held !== undefined && !relabel)
                     continue;
-                candidates.set(e.id, {
+                state.candidates.set(e.id, {
                     id: e.id, sourceStore: storeOf(isGlobal), pool: wanted, stage: null, reason: null, score: null, tokens: null,
                 });
             }
         }),
-        reject: (e, stage, reason, score, tokens) => guard(() => rejectId(e.id, stage, reason, score ?? null, tokens ?? null)),
+        reject: (e, stage, reason, score, tokens) => guard(() => rejectId(state, e.id, stage, reason, score ?? null, tokens ?? null)),
         dropMissing: (before, after, stage, reason) => guard(() => {
             const kept = new Set(after.map((e) => e.id));
             for (const e of before)
                 if (!kept.has(e.id))
-                    rejectId(e.id, stage, reason, null, null);
+                    rejectId(state, e.id, stage, reason, null, null);
         }),
         gated: (prompt, items, gate, kept) => guard(() => {
             const keptIds = new Set(kept.map((g) => g.item.id));
@@ -190,29 +164,74 @@ export function createDeliveryRecorder(init) {
                     continue;
                 const { score, shared } = scoreOverlap(prompt, c.tokens, gate.metric);
                 const cleared = score >= gate.threshold && shared >= gate.minShared;
-                rejectId(c.id, 'gate', cleared ? 'gate-max-items' : 'gate-below-threshold', score, null);
+                rejectId(state, c.id, 'gate', cleared ? 'gate-max-items' : 'gate-below-threshold', score, null);
             }
         }),
         selected: (items) => guard(() => {
-            picked.clear();
+            state.picked.clear();
             items.forEach((r, i) => {
-                picked.set(r.entry.id, {
+                state.picked.set(r.entry.id, {
                     entry: r.entry, rank: i + 1, score: r.score, tokens: r.tokens,
                     sourceStore: storeOf(r.isGlobal), promptRecall: r.promptRecall === true,
                 });
             });
         }),
-        delivered: (o) => guard(() => { outcome = { ...o }; }),
+    };
+}
+/** A recorder for one call; every observer method is guarded, and a throw marks it broken instead of escaping. */
+export function createDeliveryRecorder(init) {
+    const startedMs = Date.now();
+    const ts = evalNow().toISOString();
+    // Test-only fault injection, as HIPPO_FAKE_NOW is for time.
+    const fault = envTestDeliveryFault();
+    const payload = readPayload(init);
+    const state = {
+        candidates: new Map(), picked: new Map(), filtered: new Set(), facts: null, shown: 0, dropped: 0,
+        disabledSeen: false, outcome: { state: 'empty' }, broken: null, flushed: false,
+    };
+    const guard = (fn) => {
+        if (state.broken !== null)
+            return;
+        try {
+            if (fault === 'observe')
+                throw new Error('injected observe fault');
+            fn();
+        }
+        catch (error) {
+            state.broken = error instanceof Error ? error.message : String(error);
+        }
+    };
+    const { qualityDropped, offer, reject, dropMissing, gated, selected } = candidateMethods(state, guard);
+    return {
+        root: init.root,
+        facts: (f) => guard(() => { state.facts = { ...f }; }),
+        sections: (s, d) => guard(() => { state.shown = s; state.dropped = d; }),
+        watchAdmit: (admit) => (e) => {
+            const ok = admit(e);
+            if (!ok)
+                guard(() => { state.filtered.add(e.id); });
+            return ok;
+        },
+        qualityDropped,
+        disabled: () => guard(() => { state.disabledSeen = true; }),
+        offer,
+        reject,
+        dropMissing,
+        gated,
+        selected,
+        delivered: (o) => guard(() => { state.outcome = { ...o }; }),
         flush: (write) => {
-            if (flushed)
+            if (state.flushed)
                 return;
-            flushed = true;
-            if (broken !== null) {
+            state.flushed = true;
+            if (state.broken !== null) {
                 // Same pinned `[hippo] delivery ledger` hook stderr line as recall-trace.ts's write failure.
-                console.error(`[hippo] delivery ledger skipped: recorder failed: ${broken}`);
+                console.error(`[hippo] delivery ledger skipped: recorder failed: ${state.broken}`);
                 return;
             }
-            const input = build();
+            if (fault === 'build')
+                throw new Error('injected build fault');
+            const input = buildEvent(init, payload, state, ts, startedMs);
             if (fault === 'flush')
                 throw new Error('injected flush fault');
             write(input);

package/dist/doctor.js

@@ -15,7 +15,7 @@ import { openHippoDbReadOnly, closeHippoDb, getSchemaVersion, getCurrentSchemaVe
 import { REPLAY_AFTER_MS, TRANSCRIPT_FILL_WINDOW_MS } from './compaction-record.js';
 import { isEmbeddingAvailable } from './local-embedding.js';
 import { CODEX_TRUST_LINE, codexHomeDir, isCodexPresent, isJsonObject } from './hooks/shared.js';
-import { planUserGlobalRepair } from './project-merge.js';
+import { planProjectRepair } from './project-merge.js';
 import { resolveTenantId } from './tenant.js';
 /** Minimum Node.js version hippo supports (package.json engines). */
 export const MIN_NODE = '22.16.0';
@@ -131,16 +131,21 @@ function compactionsCheck(db, now) {
             : { id: 'compactions', status: 'warn', detail: `cannot read the compaction records: ${message}` };
     }
 }
-/** Merged rows older sleep saved as user-global, counted by the repair's own dry run so a truly user-global merge never warns. */
+/** 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 = planUserGlobalRepair(db, resolveTenantId({}));
-        const n = r.toProject.length + r.setAside.length;
-        return n === 0
-            ? { id: 'projects', status: 'pass', detail: 'no merged memories in the global store are tagged user-global by mistake' }
-            : { id: 'projects', status: 'warn', detail: `${n} merged memories in the global store are tagged user-global, so every project's context can show them`, fix: 'hippo projects repair --global   (dry run; add --apply to write)' };
+        const r = planProjectRepair(db, globalRoot, resolveTenantId({}));
+        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.collisions.length > 0 ? `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` : '',
+        ].filter((s) => s !== '');
+        return found.length === 0
+            ? { id: 'projects', status: 'pass', detail: 'no duplicate or out-of-date project tags in the global store' }
+            : { id: 'projects', status: 'warn', detail: `global store: ${found.join('; ')}`, fix: 'hippo projects repair --global   (dry run; add --apply to write)' };
     }
     catch (err) {
         return { id: 'projects', status: 'info', detail: `project tags not checked (${err instanceof Error ? err.message : String(err)})` };
@@ -150,124 +155,138 @@ function projectsCheck(globalRoot) {
             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` };
+}
+/** 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)` : ''}` } };
+    }
+    if (local !== null) {
+        // The walk stops at the first .hippo it finds, so a bare one (no hippo.db) blocks a parent or global store too.
+        return { store: null, check: { id: 'store', status: 'fail', detail: `${local} has no hippo.db, so hippo commands run here stop at it`, fix: `run hippo init in ${path.dirname(local)}, or remove that .hippo folder` } };
+    }
+    if (hasGlobal) {
+        return { store: globalRoot, check: { id: 'store', status: 'warn', detail: `no project store here; using the global store at ${globalRoot}`, fix: 'hippo init   (in the project root)' } };
+    }
+    return { store: null, check: { id: 'store', status: 'fail', detail: 'no hippo store found (project or global)', fix: 'hippo init   (in the project root), or hippo init --global' } };
+}
+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` };
+}
+function memoriesCheck(db) {
+    const memories = countTableRows(db, 'memories');
+    const dormant = countTableRows(db, 'dormant_memories');
+    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;
+}
+function tokensCheck(db, since) {
+    try {
+        // SAFETY: COUNT/SUM aggregate row.
+        const row = db.prepare(`SELECT COUNT(CASE WHEN event = 'inject' THEN 1 END) AS n,
+              COALESCE(SUM(CASE WHEN event = 'inject' THEN tokens END), 0) AS t,
+              COALESCE(SUM(CASE WHEN event = 'reread' THEN tokens END), 0) AS r
+       FROM token_ledger WHERE ts >= ?`).get(since);
+        return {
+            id: 'tokens',
+            status: 'info',
+            detail: `${Number(row?.n ?? 0)} memory blocks sent to agents in 7 days, about ${Number(row?.t ?? 0)} tokens sent and ${Number(row?.r ?? 0)} re-read by later model calls (hippo tokens for detail)`,
+        };
+    }
+    catch {
+        return { id: 'tokens', status: 'info', detail: 'no token ledger yet (created on the next write)' };
+    }
+}
+/** Checks that read the store's database; a failed open becomes a failed schema check after whatever already passed. */
+function databaseChecks(store, now) {
+    const checks = [];
+    let db = null;
+    try {
+        db = openHippoDbReadOnly(store);
+        const have = getSchemaVersion(db);
+        checks.push(schemaCheck(have, getCurrentSchemaVersion()));
+        checks.push(memoriesCheck(db));
+        const since = new Date(now.getTime() - 7 * 86_400_000).toISOString();
+        checks.push(tokensCheck(db, since));
+        checks.push(failuresCheck(db, since, have));
+        checks.push(sleepCheck(db, now));
+        checks.push(compactionsCheck(db, now));
+    }
+    catch (err) {
+        checks.push({
+            id: 'schema',
+            status: 'fail',
+            detail: `cannot open the database: ${err instanceof Error ? err.message : String(err)}`,
+            fix: err instanceof IncompatibleBinaryError ? 'npm install -g hippo-memory@latest' : 'check file permissions on the .hippo folder',
+        });
+    }
+    finally {
+        if (db !== null)
+            closeHippoDb(db);
+    }
+    return checks;
+}
+// Each hook and what it does, so a partial install says what is missing.
+const CLAUDE_CODE_HOOKS = [
+    ['hippo context --pinned-only', 'per-prompt memory'],
+    ['hippo session-end', 'session-end capture and sleep'],
+    ['hippo pre-compact', 'compaction snapshot and memories request'],
+    ['hippo compact-resume', 'resume after compaction'],
+    ['hippo post-compact', 'saving the memories a compaction lists'],
+    ['hippo capture-error', 'failed-tool capture'],
+];
+function claudeCodeCheck(home) {
+    const claudeDir = path.join(home, '.claude');
+    if (!fs.existsSync(claudeDir)) {
+        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)' };
+    }
+    if (missing.length === 0) {
+        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: hippo hooks missing for ${missing.join(', ')}`, fix: 'hippo hook install claude-code   (adds only what is missing)' };
+}
 /** Run every check. Never throws for a broken install; broken parts become failed checks. */
 export function runDoctor(opts) {
     const cwd = opts.cwd ?? process.cwd();
     const home = opts.home ?? os.homedir();
     const now = opts.now ?? new Date();
     const checks = [];
-    const node = opts.nodeVersion ?? process.versions.node;
-    checks.push(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` });
+    checks.push(nodeCheck(opts.nodeVersion ?? process.versions.node));
     const local = findHippoStoreDir(cwd);
     const globalRoot = getGlobalRoot();
     const hasGlobal = isInitialized(globalRoot);
-    let store = null;
-    if (local !== null && isInitialized(local)) {
-        store = local;
-        checks.push({ id: 'store', status: 'pass', detail: `project store at ${local}${hasGlobal ? ` (global store at ${globalRoot} too)` : ''}` });
-    }
-    else if (local !== null) {
-        // The walk stops at the first .hippo it finds, so a bare one (no hippo.db) blocks a parent or global store too.
-        checks.push({ id: 'store', status: 'fail', detail: `${local} has no hippo.db, so hippo commands run here stop at it`, fix: `run hippo init in ${path.dirname(local)}, or remove that .hippo folder` });
-    }
-    else if (hasGlobal) {
-        store = globalRoot;
-        checks.push({ id: 'store', status: 'warn', detail: `no project store here; using the global store at ${globalRoot}`, fix: 'hippo init   (in the project root)' });
-    }
-    else {
-        checks.push({ id: 'store', status: 'fail', detail: 'no hippo store found (project or global)', fix: 'hippo init   (in the project root), or hippo init --global' });
-    }
-    if (store !== null) {
-        let db = null;
-        try {
-            db = openHippoDbReadOnly(store);
-            const have = getSchemaVersion(db);
-            const want = getCurrentSchemaVersion();
-            checks.push(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` });
-            const memories = countTableRows(db, 'memories');
-            const dormant = countTableRows(db, 'dormant_memories');
-            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)';
-            }
-            checks.push(memoryCheck);
-            const since = new Date(now.getTime() - 7 * 86_400_000).toISOString();
-            try {
-                // SAFETY: COUNT/SUM aggregate row.
-                const row = db.prepare(`SELECT COUNT(CASE WHEN event = 'inject' THEN 1 END) AS n,
-                  COALESCE(SUM(CASE WHEN event = 'inject' THEN tokens END), 0) AS t,
-                  COALESCE(SUM(CASE WHEN event = 'reread' THEN tokens END), 0) AS r
-           FROM token_ledger WHERE ts >= ?`).get(since);
-                checks.push({
-                    id: 'tokens',
-                    status: 'info',
-                    detail: `${Number(row?.n ?? 0)} memory blocks sent to agents in 7 days, about ${Number(row?.t ?? 0)} tokens sent and ${Number(row?.r ?? 0)} re-read by later model calls (hippo tokens for detail)`,
-                });
-            }
-            catch {
-                checks.push({ id: 'tokens', status: 'info', detail: 'no token ledger yet (created on the next write)' });
-            }
-            checks.push(failuresCheck(db, since, have));
-            checks.push(sleepCheck(db, now));
-            checks.push(compactionsCheck(db, now));
-        }
-        catch (err) {
-            checks.push({
-                id: 'schema',
-                status: 'fail',
-                detail: `cannot open the database: ${err instanceof Error ? err.message : String(err)}`,
-                fix: err instanceof IncompatibleBinaryError ? 'npm install -g hippo-memory@latest' : 'check file permissions on the .hippo folder',
-            });
-        }
-        finally {
-            if (db !== null)
-                closeHippoDb(db);
-        }
-    }
+    const { store, check } = storeCheck(local, globalRoot, hasGlobal);
+    checks.push(check);
+    if (store !== null)
+        checks.push(...databaseChecks(store, now));
     const holdoutRateBp = store === null ? 0 : loadConfig(store).pilot.holdoutRateBp;
     if (holdoutRateBp > 0) {
         checks.push({ id: 'pilot', status: 'info', detail: `pilot holdout on: about ${holdoutRateBp / 100}% of sessions get no memories pushed by hippo (pilot.holdoutRateBp=${holdoutRateBp})` });
     }
     if (hasGlobal)
         checks.push(projectsCheck(globalRoot));
-    const claudeDir = path.join(home, '.claude');
-    if (fs.existsSync(claudeDir)) {
-        const settings = readJson(path.join(claudeDir, 'settings.json'));
-        const text = settings === null ? '' : JSON.stringify(settings);
-        const viaPlugin = /hippo-memory@/.test(text);
-        // Each hook and what it does, so a partial install says what is missing.
-        const hooks = [
-            ['hippo context --pinned-only', 'per-prompt memory'],
-            ['hippo session-end', 'session-end capture and sleep'],
-            ['hippo pre-compact', 'compaction snapshot and memories request'],
-            ['hippo compact-resume', 'resume after compaction'],
-            ['hippo post-compact', 'saving the memories a compaction lists'],
-            ['hippo capture-error', 'failed-tool capture'],
-        ];
-        const missing = hooks.filter(([marker]) => !text.includes(marker)).map(([, what]) => what);
-        if (viaPlugin) {
-            checks.push({ id: 'claude-code', status: 'pass', detail: 'Claude Code: hippo plugin enabled (all hooks, including compaction and failed-tool capture)' });
-        }
-        else if (missing.length === 0) {
-            checks.push({ id: 'claude-code', status: 'pass', detail: 'Claude Code: all hippo hooks installed, including compaction and failed-tool capture' });
-        }
-        else if (missing.length === hooks.length) {
-            checks.push({ id: 'claude-code', status: 'warn', detail: 'Claude Code found, but no hippo hooks are installed', fix: 'hippo hook install claude-code' });
-        }
-        else {
-            checks.push({ id: 'claude-code', status: 'warn', detail: `Claude Code: hippo hooks missing for ${missing.join(', ')}`, fix: 'hippo hook install claude-code   (adds only what is missing)' });
-        }
-    }
-    else {
-        checks.push({ id: 'claude-code', status: 'info', detail: 'Claude Code not found; other agents can use hippo over MCP (hippo mcp)' });
-    }
+    checks.push(claudeCodeCheck(home));
     if (isCodexPresent(home))
         checks.push(codexCheck(home));
     checks.push({ id: 'embeddings', status: 'info', detail: isEmbeddingAvailable() ? 'local embeddings available (hybrid search)' : 'embeddings not installed; recall uses BM25 (optional: hippo embed --help)' });

package/dist/dormant.js

@@ -1,4 +1,5 @@
 import { rejectionDigest } from './rejection.js';
+import { escapeLike } from './escape.js';
 const DEFAULT_LIST_LIMIT = 20;
 /**
  * Insert (or refresh) the dormant snapshot for `move.entry`. Does not touch
@@ -17,10 +18,6 @@ export function insertDormantRow(db, move) {
       dormant_at = excluded.dormant_at
   `).run(move.entry.tenantId, move.entry.id, move.entry.content, JSON.stringify(move.entry), move.reason, move.strength, move.dormantAt);
 }
-/** Escape LIKE metacharacters so a search term matches literally (ESCAPE '\'). */
-function escapeLike(term) {
-    return term.replace(/[\\%_]/g, (ch) => `\\${ch}`);
-}
 /**
  * Parse a stored snapshot back into a MemoryEntry, or null when the row no
  * longer matches the snapshot it carries (edited by hand, or truncated).