hippo-memory 1.44.0 → 1.45.0

package/dist/client.js

@@ -1,9 +1,9 @@
 /**
  * HTTP client wrapper for `hippo serve`.
  *
- * Mirrors the function signatures in src/api.ts so the CLI can route through
- * either path uniformly. Each function takes (serverUrl, apiKey?, ...) and
- * returns the same shape that api.ts would.
+ * Only the writes the CLI routes (remember, forget, archive, promote), which are
+ * also all HIPPO_REQUIRE_SERVER covers; every other command opens the store
+ * directly. Each call returns the same shape that api.ts would.
  *
  * Errors from the server (4xx/5xx) are mapped back into thrown Errors with
  * the server's `error` message preserved verbatim so existing CLI handlers
@@ -65,52 +65,6 @@ export async function remember(serverUrl, apiKey, opts) {
     const result = await res.json();
     return result;
 }
-export async function recall(serverUrl, apiKey, opts) {
-    const params = new URLSearchParams();
-    params.set('q', opts.query);
-    if (opts.limit !== undefined)
-        params.set('limit', String(opts.limit));
-    if (opts.mode !== undefined)
-        params.set('mode', opts.mode);
-    if (opts.scope !== undefined && opts.scope !== '')
-        params.set('scope', opts.scope);
-    if (opts.includeContinuity)
-        params.set('include_continuity', '1');
-    // v1.7.2 T4 — RecallOpts parity sweep. Pre-v1.7.2 the thin-client only
-    // serialized the five fields above; the HTTP server already accepted
-    // fresh_tail_count, fresh_tail_session_id, summarize_overflow. Adding
-    // scorer_window alone would have perpetuated the drift. Serializing all
-    // four together. Validation lives in api.recall(); transport just
-    // forwards.
-    if (opts.freshTailCount !== undefined)
-        params.set('fresh_tail_count', String(opts.freshTailCount));
-    if (opts.freshTailSessionId !== undefined && opts.freshTailSessionId !== '')
-        params.set('fresh_tail_session_id', opts.freshTailSessionId);
-    if (opts.summarizeOverflow !== undefined)
-        params.set('summarize_overflow', opts.summarizeOverflow ? '1' : '0');
-    if (opts.scorerWindow !== undefined)
-        params.set('scorer_window', String(opts.scorerWindow));
-    // v1.7.4 sessionId for dlPFC goal-stack boost + v0.33 / J1 sessionId
-    // for per-session anchoring ring. Pre-v0.33 the thin-client silently
-    // dropped opts.sessionId, so HTTP-routed SDK callers got no goal
-    // boost and (post-J1) the HTTP ring logged recall_anchor_skipped_no_session.
-    // Codex round-3 P2 catch: align serialization with the RecallOpts type.
-    // Note: opts.recallHistory is intentionally NOT serialized — it is an
-    // in-process snapshot only; the HTTP server maintains its own ring per
-    // sessionId, so passing recallHistory over the wire would be a no-op
-    // at best and a tenant-leak risk at worst.
-    if (opts.sessionId !== undefined && opts.sessionId !== '') {
-        params.set('session_id', opts.sessionId);
-    }
-    const res = await fetch(`${serverUrl}/v1/memories?${params.toString()}`, {
-        method: 'GET',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
 export async function forget(serverUrl, apiKey, id) {
     const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(id)}`, {
         method: 'DELETE',
@@ -131,17 +85,6 @@ export async function promote(serverUrl, apiKey, id) {
     const result = await res.json();
     return result;
 }
-export async function supersede(serverUrl, apiKey, oldId, newContent) {
-    const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(oldId)}/supersede`, {
-        method: 'POST',
-        headers: buildHeaders(apiKey, true),
-        body: JSON.stringify({ content: newContent }),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
 export async function archiveRaw(serverUrl, apiKey, id, reason) {
     const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(id)}/archive`, {
         method: 'POST',
@@ -153,58 +96,6 @@ export async function archiveRaw(serverUrl, apiKey, id, reason) {
     const result = await res.json();
     return result;
 }
-export async function authCreate(serverUrl, apiKey, opts) {
-    const res = await fetch(`${serverUrl}/v1/auth/keys`, {
-        method: 'POST',
-        headers: buildHeaders(apiKey, true),
-        body: JSON.stringify(opts),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
-export async function authList(serverUrl, apiKey, opts) {
-    const params = new URLSearchParams();
-    params.set('active', opts.active ? 'true' : 'false');
-    const res = await fetch(`${serverUrl}/v1/auth/keys?${params.toString()}`, {
-        method: 'GET',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
-export async function authRevoke(serverUrl, apiKey, keyId) {
-    const res = await fetch(`${serverUrl}/v1/auth/keys/${encodeURIComponent(keyId)}`, {
-        method: 'DELETE',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
-export async function auditList(serverUrl, apiKey, opts) {
-    const params = new URLSearchParams();
-    if (opts.op !== undefined)
-        params.set('op', opts.op);
-    if (opts.since !== undefined)
-        params.set('since', opts.since);
-    if (opts.limit !== undefined)
-        params.set('limit', String(opts.limit));
-    const qs = params.toString();
-    const url = qs.length > 0 ? `${serverUrl}/v1/audit?${qs}` : `${serverUrl}/v1/audit`;
-    const res = await fetch(url, {
-        method: 'GET',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
 function hasObjectCause(e) {
     // Node's fs/net system errors (ECONNREFUSED, ECONNRESET) attach the syscall
     // code on a non-null object `cause`; the strict-equality checks below

package/dist/config.js

@@ -4,8 +4,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { DEFAULT_PHYSICS_CONFIG, mergePhysicsConfig } from './physics-config.js';
+import { DEFAULT_HALF_LIFE_DAYS } from './memory.js';
 const DEFAULT_CONFIG = {
-    defaultHalfLifeDays: 7,
+    defaultHalfLifeDays: DEFAULT_HALF_LIFE_DAYS,
     defaultBudget: 4000,
     defaultContextBudget: 3000,
     decayBasis: 'adaptive',

package/dist/consolidate.d.ts

@@ -26,6 +26,8 @@ export interface ConsolidationResult {
     dryRun: boolean;
     details: string[];
     physicsSimulated: number;
+    /** Ids the decay pass removes (or would remove, under dryRun). */
+    removedIds?: string[];
 }
 /**
  * Run a full consolidation pass.
@@ -33,5 +35,6 @@ export interface ConsolidationResult {
 export declare function consolidate(hippoRoot: string, options?: {
     dryRun?: boolean;
     now?: Date;
+    fetcher?: typeof fetch;
 }): Promise<ConsolidationResult>;
 //# sourceMappingURL=consolidate.d.ts.map

package/dist/consolidate.js

@@ -7,7 +7,7 @@
  * 3. Stats tracking
  */
 import { evalNow, isRecallBoostAblated } from './ablation.js';
-import { Layer, calculateStrength, createMemory } from './memory.js';
+import { Layer, calculateStrength, canAutoDelete, createMemory } from './memory.js';
 import { loadAllEntries, batchWriteAndDelete, appendConsolidationRun, replaceDetectedConflicts, loadSessionDecayContext, incrementSleepCount, findPromotableSessions, traceExistsForSession, listSessionEvents, } from './store.js';
 import { textOverlap, markRetrieved } from './search.js';
 import { compareEntryIdentity } from './compare.js';
@@ -91,6 +91,7 @@ export async function consolidate(hippoRoot, options = {}) {
     // with no cross-tenant dedup. The api.sleep audit row tags this with the
     // admin synthetic actor; see api.ts:2050 for the rationale.
     const all = loadAllEntries(hippoRoot);
+    const snapshot = new Map(structuredClone(all).map((e) => [e.id, e]));
     // Load decay options from config + session context
     const config = loadConfig(hippoRoot);
     const sessionCtx = loadSessionDecayContext(hippoRoot);
@@ -131,12 +132,12 @@ export async function consolidate(hippoRoot, options = {}) {
         for (const entry of all) {
             const strength = calculateStrength(entry, now, decayOpts);
             strengthById.set(entry.id, strength);
-            if (!entry.pinned && strength < DECAY_THRESHOLD) {
+            if (canAutoDelete(entry) && strength < DECAY_THRESHOLD) {
                 condemned.push(entry);
             }
         }
         // --- Phase 2a: rescue decision (pure compute) ---
-        // Runs under --dry-run too (only pendingDeletes/the audit write in
+        // Runs under --dry-run too (only the pendingDeletes flush and the audit write in
         // "4. Log run" below stay !dryRun-gated), so the preview matches what a
         // real run would decide.
         const condemnedIds = new Set(condemned.map((e) => e.id));
@@ -173,7 +174,7 @@ export async function consolidate(hippoRoot, options = {}) {
         // preserves flag-off's ordering semantics exactly.)
         for (const entry of all) {
             const strength = strengthById.get(entry.id);
-            if (!entry.pinned && strength < DECAY_THRESHOLD) {
+            if (canAutoDelete(entry) && strength < DECAY_THRESHOLD) {
                 if (rescuedIds.has(entry.id)) {
                     // Rescued (D1): standard survivor stored-strength refresh (P2-1).
                     // Confidence is left alone here: it is an epistemic tier, not a
@@ -194,9 +195,7 @@ export async function consolidate(hippoRoot, options = {}) {
                 else {
                     result.removed++;
                     result.details.push(`  🗑  removed ${entry.id} (strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})`);
-                    if (!dryRun) {
-                        pendingDeletes.push(entry.id);
-                    }
+                    pendingDeletes.push(entry.id);
                 }
             }
             else {
@@ -212,12 +211,10 @@ export async function consolidate(hippoRoot, options = {}) {
     else {
         for (const entry of all) {
             const strength = calculateStrength(entry, now, decayOpts);
-            if (!entry.pinned && strength < DECAY_THRESHOLD) {
+            if (canAutoDelete(entry) && strength < DECAY_THRESHOLD) {
                 result.removed++;
                 result.details.push(`  🗑  removed ${entry.id} (strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})`);
-                if (!dryRun) {
-                    pendingDeletes.push(entry.id);
-                }
+                pendingDeletes.push(entry.id);
             }
             else {
                 // Only strength is a cached computation; confidence stays as stored.
@@ -423,26 +420,34 @@ export async function consolidate(hippoRoot, options = {}) {
         // 1.6. Batch extraction — extract facts from episodic memories missing them
         // -------------------------------------------------------------------------
         const extractedFromIds = new Set(survivors.filter((e) => e.extracted_from).map((e) => e.extracted_from));
-        const extractionCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !extractedFromIds.has(e.id));
+        const extractionCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.superseded_by && !extractedFromIds.has(e.id));
         result.extractionCandidates = extractionCandidates.length;
-        const apiKey = process.env.ANTHROPIC_API_KEY ?? '';
+        // extraction.enabled=false is the opt-out for every LLM phase below, key or no key.
+        const apiKey = config.extraction.enabled !== false ? (process.env.ANTHROPIC_API_KEY ?? '') : '';
+        const llmErrorsSeen = new Set();
+        const llmError = (phase) => (msg) => {
+            const line = `  ⚠️ ${phase}: ${msg}`;
+            if (llmErrorsSeen.has(line))
+                return;
+            llmErrorsSeen.add(line);
+            result.details.push(line);
+            console.error(`consolidate ${phase}: ${msg}`);
+        };
+        const llmOpts = { apiKey, model: config.extraction.model, fetcher: options.fetcher };
         if (apiKey && extractionCandidates.length > 0 && !dryRun) {
             const { extractFacts, storeExtractedFacts } = await import('./extract.js');
             const batchLimit = 20;
             let extractedCount = 0;
             for (const candidate of extractionCandidates.slice(0, batchLimit)) {
                 try {
-                    const facts = await extractFacts(candidate.content, {
-                        apiKey,
-                        model: config.extraction.model,
-                    });
+                    const facts = await extractFacts(candidate.content, { ...llmOpts, onError: llmError('extraction') });
                     if (facts.length > 0) {
                         storeExtractedFacts(hippoRoot, candidate, facts);
                         extractedCount += facts.length;
                     }
                 }
-                catch {
-                    // Best-effort — continue with next candidate
+                catch (err) {
+                    llmError('extraction')(String(err));
                 }
             }
             result.extracted = extractedCount;
@@ -450,22 +455,19 @@ export async function consolidate(hippoRoot, options = {}) {
         // -------------------------------------------------------------------------
         // 1.7. DAG summarization — cluster extracted facts and generate summaries
         // -------------------------------------------------------------------------
-        const extractedFacts = survivors.filter((e) => e.tags.includes('extracted') && e.dag_level === 1);
+        const extractedFacts = survivors.filter((e) => e.tags.includes('extracted') && e.dag_level === 1 && !e.superseded_by);
         if (apiKey && extractedFacts.length >= 3 && !dryRun) {
             try {
                 const { buildDag } = await import('./dag.js');
-                const dagResult = await buildDag(hippoRoot, extractedFacts, {
-                    apiKey,
-                    model: config.extraction.model,
-                });
+                const dagResult = await buildDag(hippoRoot, extractedFacts, { ...llmOpts, onError: llmError('dag') });
                 result.dagCandidateClusters = dagResult.candidateClusters;
                 result.dagSummariesCreated = dagResult.summariesCreated;
                 if (dagResult.summariesCreated > 0) {
                     result.details.push(`  🌳 DAG: ${dagResult.summariesCreated} summaries created, ${dagResult.factsLinked} facts linked`);
                 }
             }
-            catch {
-                // Best-effort
+            catch (err) {
+                llmError('dag')(String(err));
             }
         }
         // -------------------------------------------------------------------------
@@ -485,11 +487,7 @@ export async function consolidate(hippoRoot, options = {}) {
                 const cap = Number.isFinite(rawCap) && rawCap > 0
                     ? Math.min(rawCap, 1000)
                     : 20;
-                const rebuildResult = await rebuildDirtySummaries(hippoRoot, {
-                    apiKey,
-                    model: config.extraction.model,
-                    cap,
-                });
+                const rebuildResult = await rebuildDirtySummaries(hippoRoot, { ...llmOpts, onError: llmError('dag rebuild'), cap });
                 result.summariesRebuilt = rebuildResult.rebuilt;
                 result.summariesRebuildFailed = rebuildResult.failed;
                 result.summariesZeroChildSkipped = rebuildResult.zeroChildSkipped;
@@ -510,8 +508,8 @@ export async function consolidate(hippoRoot, options = {}) {
                     result.details.push(`  🌳 DAG rebuild: ${parts.join(', ')}`);
                 }
             }
-            catch {
-                // Best-effort — same posture as buildDag block above.
+            catch (err) {
+                llmError('dag rebuild')(String(err));
             }
         }
         // -------------------------------------------------------------------------
@@ -529,18 +527,15 @@ export async function consolidate(hippoRoot, options = {}) {
                 const { loadAllL2Summaries } = await import('./store.js');
                 const l2Summaries = loadAllL2Summaries(hippoRoot);
                 if (l2Summaries.length >= 2) {
-                    const profileResult = await buildEntityProfiles(hippoRoot, l2Summaries, {
-                        apiKey,
-                        model: config.extraction.model,
-                    });
+                    const profileResult = await buildEntityProfiles(hippoRoot, l2Summaries, { ...llmOpts, onError: llmError('dag profiles') });
                     result.entityProfilesCreated = profileResult.profilesCreated;
                     if (profileResult.profilesCreated > 0) {
                         result.details.push(`  🌲 DAG L3: ${profileResult.profilesCreated} entity profiles, ${profileResult.l2sLinked} L2s linked`);
                     }
                 }
             }
-            catch {
-                // Best-effort.
+            catch (err) {
+                llmError('dag profiles')(String(err));
             }
         }
         // -------------------------------------------------------------------------
@@ -599,7 +594,7 @@ export async function consolidate(hippoRoot, options = {}) {
         // -------------------------------------------------------------------------
         // 3. Merge pass  - episodic entries only
         // -------------------------------------------------------------------------
-        const mergeCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.tags.includes('extracted'));
+        const mergeCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.superseded_by && !e.tags.includes('extracted'));
         const used = new Set();
         // T1 fix (2026-08-15 hardening pass): partition by tenantId BEFORE the
         // overlap loop so a cluster can never span tenants. Previously textOverlap
@@ -735,9 +730,16 @@ export async function consolidate(hippoRoot, options = {}) {
     if (mergesSkippedRejected > 0) {
         console.error(`consolidate: skipped ${mergesSkippedRejected} merge(s) whose content matches a rejected value`);
     }
-    // Flush all writes/deletes in a single transaction
+    result.removedIds = pendingDeletes;
+    // One transaction; the snapshot keeps what the DAG passes and other writers changed while sleep ran.
     if (!dryRun) {
-        batchWriteAndDelete(hippoRoot, pendingWrites, pendingDeletes);
+        const deleted = new Set(batchWriteAndDelete(hippoRoot, pendingWrites, pendingDeletes, { snapshot }));
+        for (const id of pendingDeletes) {
+            if (!deleted.has(id))
+                result.details.push(`  ↩  ${id} not removed: pinned or already gone before sleep saved`);
+        }
+        result.removedIds = pendingDeletes.filter((id) => deleted.has(id));
+        result.removed = result.removedIds.length;
     }
     // -------------------------------------------------------------------------
     // 4. Log run

package/dist/dag.d.ts

@@ -9,6 +9,7 @@ export interface DagSummaryOptions {
     apiKey: string;
     model?: string;
     fetcher?: typeof fetch;
+    onError?: (msg: string) => void;
 }
 export declare function generateDagSummary(label: string, factContents: string[], opts: DagSummaryOptions): Promise<string | null>;
 export interface DagBuildResult {

package/dist/dag.js

@@ -1,6 +1,7 @@
 import { createMemory, Layer } from './memory.js';
 import { writeEntry, loadAllDirtySummaries, loadChildrenOfSummary, applyRebuildResult, clearSummaryDirtyAfterBuild, } from './store.js';
 import { RejectedValueError } from './rejection.js';
+import { redactSecrets } from './secret-detect.js';
 export function clusterFacts(facts) {
     if (facts.length === 0)
         return [];
@@ -42,9 +43,9 @@ Write a single concise paragraph (2-4 sentences) that captures all the key infor
 export async function generateDagSummary(label, factContents, opts) {
     const model = opts.model ?? 'claude-sonnet-4-6';
     const fetchFn = opts.fetcher ?? fetch;
-    const factsBlock = factContents.map((f, i) => `${i + 1}. ${f}`).join('\n');
+    const factsBlock = factContents.map((f, i) => `${i + 1}. ${redactSecrets(f)}`).join('\n');
     const prompt = DAG_SUMMARY_PROMPT
-        .replace('{label}', label)
+        .replace('{label}', redactSecrets(label))
         .replace('{facts}', factsBlock);
     let res;
     try {
@@ -62,17 +63,21 @@ export async function generateDagSummary(label, factContents, opts) {
             }),
         });
     }
-    catch {
+    catch (err) {
+        opts.onError?.(`request failed: ${err instanceof Error ? err.message : String(err)}`);
         return null;
     }
-    if (!res.ok)
+    if (!res.ok) {
+        opts.onError?.(`HTTP ${res.status}`);
         return null;
+    }
     try {
         const data = await res.json();
         const text = data.content?.[0]?.text?.trim() ?? '';
         return text.length >= 20 ? text : null;
     }
-    catch {
+    catch (err) {
+        opts.onError?.(`unparseable response: ${err instanceof Error ? err.message : String(err)}`);
         return null;
     }
 }

package/dist/dashboard.js

@@ -14,6 +14,7 @@ import { listPeers } from './shared.js';
 import { loadEmbeddingIndex } from './embeddings.js';
 import { resolveTenantId } from './tenant.js';
 import { loadCardDetail } from './card-detail.js';
+import { isCrossSite, LOOPBACK_HOST_HEADER } from './server.js';
 function buildDashboardData(hippoRoot) {
     // A5: scope dashboard to active tenant. Without this, the UI surfaces every
     // tenant's memories on a multi-tenant deployment.
@@ -122,8 +123,6 @@ const MIME_TYPES = {
     '.ico': 'image/x-icon',
     '.woff2': 'font/woff2',
 };
-// Binds 127.0.0.1 only; refusing other Hosts closes the DNS-rebinding route.
-const LOOPBACK_HOST = /^(localhost|127\.0\.0\.1)(:\d+)?$/i;
 function isStaticFileExtension(ext) {
     return Object.hasOwn(MIME_TYPES, ext);
 }
@@ -156,7 +155,7 @@ export function serveDashboard(hippoRoot, port = 3333) {
     const hasDistUi = fs.existsSync(path.join(distUiDir, 'index.html'));
     const handleRequest = (req, res) => {
         const host = req.headers.host;
-        if (host !== undefined && !LOOPBACK_HOST.test(host)) {
+        if (host !== undefined && !LOOPBACK_HOST_HEADER.test(host)) {
             res.writeHead(403, { 'Content-Type': 'text/plain' });
             res.end('Forbidden');
             return;
@@ -168,6 +167,11 @@ export function serveDashboard(hippoRoot, port = 3333) {
             // POST /api/star/:id - toggle starred on a memory
             const starMatch = pathname.match(/^\/api\/star\/([A-Za-z0-9_\-]+)$/);
             if (starMatch && req.method === 'POST') {
+                if (isCrossSite(req)) {
+                    res.writeHead(403, { 'Content-Type': 'text/plain' });
+                    res.end('Forbidden');
+                    return;
+                }
                 const id = starMatch[1];
                 const entry = readEntry(hippoRoot, id, resolveTenantId({}));
                 if (!entry)

package/dist/db.js

@@ -2389,16 +2389,12 @@ export function getHippoDbPath(hippoRoot) {
 export function getCurrentSchemaVersion() {
     return CURRENT_SCHEMA_VERSION;
 }
-function readMinCompatibleBinary(db) {
-    // Tolerate the meta table not yet existing on a fresh DB.
-    try {
-        // SAFETY: row's shape matches the single `value` column named in the
-        // SELECT above.
-        const row = db.prepare(`SELECT value FROM meta WHERE key = 'min_compatible_binary'`).get();
-        return row?.value ?? null;
-    }
-    catch {
-        return null;
+/** Refuse a store stamped for a newer binary. Fails closed: runMigrations creates meta first, so a failed read is a real error. */
+function assertBinaryCompatible(db) {
+    const minRequired = getMeta(db, 'min_compatible_binary');
+    if (minRequired && compareSemver(minRequired, PACKAGE_VERSION) > 0) {
+        throw new Error(`hippo-memory: this database requires hippo-memory >= ${minRequired}, but the running binary is ${PACKAGE_VERSION}. ` +
+            `Upgrade hippo-memory to open it; an older binary does not know this schema and could expose private rows or damage the store.`);
     }
 }
 function isSqliteBusy(error) {
@@ -2456,17 +2452,8 @@ export function openHippoDb(hippoRoot) {
 }
 function runMigrations(db, hippoRoot) {
     ensureMetaTable(db);
-    // v1.3.1 rollback-safety guard. Schema v24 stamped meta.min_compatible_binary;
-    // older binaries that lack the generic *:private:* default-deny filter would
-    // leak github:private:* rows on no-scope recall. Refuse to open a DB stamped
-    // with a min newer than this binary's version. Read BEFORE migrations so a
-    // stale v1.2.0 binary cannot apply unknown future migrations either.
-    const minRequired = readMinCompatibleBinary(db);
-    if (minRequired && compareSemver(minRequired, PACKAGE_VERSION) > 0) {
-        throw new Error(`hippo-memory: this database requires hippo-memory >= ${minRequired}, but the running binary is ${PACKAGE_VERSION}. ` +
-            `Upgrade hippo-memory to open this database. Running an older binary against this DB would leak private rows that the ` +
-            `older filter does not recognize.`);
-    }
+    // Before anything writes, so a stale binary never repairs or migrates a store it does not understand.
+    assertBinaryCompatible(db);
     let currentVersion = getSchemaVersion(db);
     if (currentVersion > 0)
         ensureContinuityTables(db);
@@ -2475,6 +2462,8 @@ function runMigrations(db, hippoRoot) {
             continue;
         execWithBusyRetry(db, 'BEGIN IMMEDIATE');
         try {
+            // A newer binary may have migrated and raised the minimum while we waited for the lock.
+            assertBinaryCompatible(db);
             // Re-read under the write lock: another process may have applied this
             // migration while we waited, and re-running one is not idempotent.
             const applied = getSchemaVersion(db);
@@ -2672,8 +2661,8 @@ function ensureOptionalFts(db) {
         backfillFtsIndex(db);
         available = true;
     }
-    catch {
-        available = false;
+    catch (err) {
+        console.error(`hippo: full-text index unavailable (${err instanceof Error ? err.message : String(err)}); search falls back to slower LIKE matching`);
     }
     // Read-first: only write when the flag actually changed, so a healthy
     // store's open doesn't take a write lock for a same-value upsert.

package/dist/dedupe.d.ts

@@ -70,5 +70,6 @@ export declare function strengthBucket(strength: number | null | undefined): num
 export declare function deduplicateStore(hippoRoot: string, options?: {
     threshold?: number;
     dryRun?: boolean;
+    actor?: string;
 }): DedupResult;
 //# sourceMappingURL=dedupe.d.ts.map

package/dist/dedupe.js

@@ -23,6 +23,7 @@
 import { textOverlap } from './search.js';
 import { loadAllEntries, deleteEntry } from './store.js';
 import { compareEntryIdentity } from './compare.js';
+import { canAutoDelete } from './memory.js';
 /** Quantization step for strength-tie comparisons. The historical 0.01
  *  epsilon (see `strengthBucket` below) applied via rounding instead of a
  *  raw abs-diff threshold, so the tiebreak is transitive. */
@@ -111,7 +112,7 @@ export function deduplicateStore(hippoRoot, options = {}) {
             if (removed.has(tenantEntries[i].id))
                 continue;
             for (let j = i + 1; j < tenantEntries.length; j++) {
-                if (removed.has(tenantEntries[j].id))
+                if (removed.has(tenantEntries[j].id) || !canAutoDelete(tenantEntries[j]))
                     continue;
                 const similarity = textOverlap(tenantEntries[i].content, tenantEntries[j].content);
                 if (similarity <= threshold)
@@ -131,11 +132,7 @@ export function deduplicateStore(hippoRoot, options = {}) {
             }
         }
     }
-    if (!dryRun) {
-        for (const id of removed) {
-            deleteEntry(hippoRoot, id);
-        }
-    }
-    return { removed: removed.size, pairs };
+    const done = dryRun ? pairs : pairs.filter((p) => deleteEntry(hippoRoot, p.removed, { actor: options.actor, reason: `dedup: duplicate of ${p.kept}`, automatic: true }));
+    return { removed: done.length, pairs: done };
 }
 //# sourceMappingURL=dedupe.js.map

package/dist/embedding-provider.js

@@ -31,6 +31,7 @@
  */
 import { getEmbedding, isEmbeddingAvailable, resolveEmbeddingModel, DEFAULT_EMBEDDING_MODEL, } from './embeddings.js';
 import { loadConfig } from './config.js';
+import { redactSecrets } from './secret-detect.js';
 export const API_PROVIDER_KINDS = ['openai', 'voyage', 'cohere'];
 function isApiProviderKind(x) {
     return x === 'openai' || x === 'voyage' || x === 'cohere';
@@ -188,7 +189,7 @@ class ApiEmbeddingProvider {
                     'content-type': 'application/json',
                     authorization: `Bearer ${key}`,
                 },
-                body: JSON.stringify(spec.buildBody(this.model, chunk, role)),
+                body: JSON.stringify(spec.buildBody(this.model, chunk.map(redactSecrets), role)),
                 signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
             });
         }