hippo-memory 1.68.0 → 1.70.0

package/dist/{prompt-recall.d.ts → core/prompt-recall.d.ts}

@@ -30,4 +30,9 @@ export declare const RAREST_TERM_COUNT = 8;
 /** Terms sorted by ascending FTS doc count (rarest first), zero-count terms dropped, ties by term.
  *  Pure: `docCount` (an FTS lookup in the caller) does the only I/O. */
 export declare function rarestPromptTerms(terms: Iterable<string>, docCount: (term: string) => number, maxTerms?: number): string[];
+/** The pieces FTS5's unicode61 tokenizer indexes a term as, so `journal_mode` is `journal` and `mode`. */
+export declare function ftsTermParts(term: string): string[];
+/** The rarest terms as a space-joined FTS query, given each part's document count; a term counts as its rarest part,
+ *  an upper bound on rows holding the whole term, and a term with no parts counts 0, so it is dropped. */
+export declare function rarestFtsQuery(terms: readonly string[], docCount: (part: string) => number, maxTerms?: number): string;
 //# sourceMappingURL=prompt-recall.d.ts.map

package/dist/{prompt-recall.js → core/prompt-recall.js}

@@ -1,5 +1,5 @@
 /** Recall gated on the hook prompt, not the five newest memories (pure, no I/O). */
-import { tokenize } from './tokenize.js';
+import { tokenize } from '../util/tokenize.js';
 import { STOP_WORDS } from './memory-quality.js';
 // Latency bound, not tuned: fixed in the prereg regardless of gate config.
 export const PROMPT_RECALL_MAX_CHARS = 4000;
@@ -64,4 +64,17 @@ export function rarestPromptTerms(terms, docCount, maxTerms = RAREST_TERM_COUNT)
         .slice(0, maxTerms)
         .map((x) => x.t);
 }
+/** The pieces FTS5's unicode61 tokenizer indexes a term as, so `journal_mode` is `journal` and `mode`. */
+export function ftsTermParts(term) {
+    return term.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+/** The rarest terms as a space-joined FTS query, given each part's document count; a term counts as its rarest part,
+ *  an upper bound on rows holding the whole term, and a term with no parts counts 0, so it is dropped. */
+export function rarestFtsQuery(terms, docCount, maxTerms = RAREST_TERM_COUNT) {
+    const termCount = (t) => {
+        const parts = ftsTermParts(t);
+        return parts.length === 0 ? 0 : Math.min(...parts.map(docCount));
+    };
+    return rarestPromptTerms(terms, termCount, maxTerms).join(' ');
+}
 //# sourceMappingURL=prompt-recall.js.map

package/dist/{salience.js → core/salience.js}

@@ -5,8 +5,17 @@
  * Inspired by the biological salience network (anterior insula + dACC):
  * not everything that enters working memory deserves long-term storage.
  */
-import { textOverlap } from './tokenize.js';
-import { duplicateKey, heldTextKeys } from './same-text.js';
+import { textOverlap } from '../util/tokenize.js';
+import { duplicateKey, heldTextKeys } from '../util/same-text.js';
+// Each store or skip reason carries a score; a novel memory adds bonuses for structure and length.
+const REPEAT_ERROR_SCORE = 0.3;
+const ERROR_DESPITE_OVERLAP_SCORE = 0.7;
+const NEAR_DUPLICATE_SCORE = 0.5;
+const DUPLICATE_SCORE = 0.1;
+const NOVEL_ERROR_SCORE = 0.9;
+const NOVEL_BASE_SCORE = 0.5;
+const STRUCTURED_TAGS_BONUS = 0.15;
+const LENGTH_BONUS = 0.1;
 const DEFAULTS = {
     recentWindow: 20,
     overlapThreshold: 0.6,
@@ -33,34 +42,40 @@ export function computeSalience(content, tags, recentMemories, options = {}) {
                 return {
                     decision: 'start_weak',
                     reason: `repeat_error (${recentErrors} recent errors, overlap ${(duplicateMatch.overlap * 100).toFixed(0)}% with ${duplicateMatch.matchId})`,
-                    score: 0.3,
+                    score: REPEAT_ERROR_SCORE,
                 };
             }
-            return { decision: 'store', reason: 'error_despite_overlap', score: 0.7 };
+            return { decision: 'store', reason: 'error_despite_overlap', score: ERROR_DESPITE_OVERLAP_SCORE };
         }
-        // A near-duplicate may be a changed value (port 8080 then 8081), so only the same text is skipped.
-        const key = duplicateKey(trimmed);
-        const same = window.find((m) => heldTextKeys(m).includes(key));
-        if (!same) {
-            return {
-                decision: 'store',
-                reason: `near_duplicate (${(duplicateMatch.overlap * 100).toFixed(0)}% overlap with ${duplicateMatch.matchId})`,
-                score: 0.5,
-            };
-        }
-        return { decision: 'skip', reason: `duplicate (same text as ${same.id})`, score: 0.1 };
+        return judgeOverlappingNonError(trimmed, window, duplicateMatch);
     }
     if (isError) {
-        return { decision: 'store', reason: 'error_novel', score: 0.9 };
+        return { decision: 'store', reason: 'error_novel', score: NOVEL_ERROR_SCORE };
+    }
+    return scoreNovel(trimmed, tags);
+}
+function judgeOverlappingNonError(trimmed, window, duplicateMatch) {
+    // A near-duplicate may be a changed value (port 8080 then 8081), so only the same text is skipped.
+    const key = duplicateKey(trimmed);
+    const same = window.find((m) => heldTextKeys(m).includes(key));
+    if (!same) {
+        return {
+            decision: 'store',
+            reason: `near_duplicate (${(duplicateMatch.overlap * 100).toFixed(0)}% overlap with ${duplicateMatch.matchId})`,
+            score: NEAR_DUPLICATE_SCORE,
+        };
     }
+    return { decision: 'skip', reason: `duplicate (same text as ${same.id})`, score: DUPLICATE_SCORE };
+}
+function scoreNovel(trimmed, tags) {
     const hasStructuredTags = tags.some(t => t.startsWith('speaker:') || t.startsWith('topic:') || t.startsWith('scope:'));
-    let score = 0.5;
+    let score = NOVEL_BASE_SCORE;
     if (hasStructuredTags)
-        score += 0.15;
+        score += STRUCTURED_TAGS_BONUS;
     if (trimmed.length > 100)
-        score += 0.1;
+        score += LENGTH_BONUS;
     if (trimmed.length > 300)
-        score += 0.1;
+        score += LENGTH_BONUS;
     return { decision: 'store', reason: 'novel', score: Math.min(score, 1.0) };
 }
 function findBestOverlap(content, memories) {

package/dist/{search/types.d.ts → core/search-types.d.ts}

@@ -1,4 +1,4 @@
-import type { MemoryEntry } from '../memory.js';
+import type { MemoryEntry } from './memory.js';
 export declare const DEFAULT_RECALL_BUDGET = 4000;
 export declare const DEFAULT_LOCAL_BUMP = 1.2;
 /** One score mutation applied after candidate generation; allocated only under `recall --why` or `RecallOpts.explain`. */
@@ -90,4 +90,4 @@ export interface ScoreBreakdown {
     /** 1.05 if a summary was rebuilt within 7 days; 1.0 otherwise. */
     summaryFreshnessBoost?: number;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=search-types.d.ts.map

package/dist/{search/types.js → core/search-types.js}

@@ -1,4 +1,4 @@
 export const DEFAULT_RECALL_BUDGET = 4000;
 // Local memories outrank global ones by this factor; getContext applies it as a 1/x global discount.
 export const DEFAULT_LOCAL_BUMP = 1.2;
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=search-types.js.map

package/dist/core/session-digest-row.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryEntry } from './memory.js';
+export declare const SESSION_DIGEST_TAG = "session-digest";
+/** Facts extracted from a digest and DAG summaries over one inherit its tag, but they are not the digest itself. */
+export declare function isSessionDigestRow(entry: Pick<MemoryEntry, 'source' | 'tags' | 'extracted_from'>): boolean;
+//# sourceMappingURL=session-digest-row.d.ts.map

package/dist/core/session-digest-row.js

@@ -0,0 +1,6 @@
+export const SESSION_DIGEST_TAG = 'session-digest';
+/** Facts extracted from a digest and DAG summaries over one inherit its tag, but they are not the digest itself. */
+export function isSessionDigestRow(entry) {
+    return entry.source === SESSION_DIGEST_TAG && entry.tags.includes(SESSION_DIGEST_TAG) && !entry.extracted_from;
+}
+//# sourceMappingURL=session-digest-row.js.map

package/dist/{dashboard-actions.d.ts → dashboard/dashboard-actions.d.ts}

@@ -1,4 +1,4 @@
-import type { MemoryEntry } from './memory.js';
+import type { MemoryEntry } from '../core/memory.js';
 import { type ActionBody } from './dashboard-params.js';
 /** What an action hands the router: a status, a JSON body, and whether the store changed. */
 export interface ActionResult {

package/dist/{dashboard-actions.js → dashboard/dashboard-actions.js}

@@ -1,9 +1,9 @@
 // The four dashboard writes, each a thin call into an existing store or api function; the router owns HTTP and the cache.
-import * as api from './api.js';
-import { NotFoundError } from './api-errors.js';
-import { listTouchableConflicts, resolveConflict } from './store/conflicts.js';
-import { readEntry } from './store/entry-reads.js';
-import { writeEntry } from './store/entry-writes.js';
+import * as api from '../api/index.js';
+import { NotFoundError } from '../core/api-errors.js';
+import { listTouchableConflicts, resolveConflict } from '../store/conflicts.js';
+import { readEntry } from '../store/entry-reads.js';
+import { writeEntry } from '../store/entry-writes.js';
 import { ParamError, parseMemoryId } from './dashboard-params.js';
 import { isLiveMemory } from './dashboard-snapshot.js';
 const ACTOR = 'dashboard';

package/dist/{dashboard-queries.d.ts → dashboard/dashboard-queries.d.ts}

@@ -1,4 +1,4 @@
-import { type MemoryEntry } from './memory.js';
+import { type MemoryEntry } from '../core/memory.js';
 import { type Snapshot } from './dashboard-snapshot.js';
 import type { MemoryQuery } from './dashboard-params.js';
 import type { MemoryDetail, MemoryPage, Overview, ProjectDetail, SearchResult } from './dashboard-types.js';
@@ -10,6 +10,11 @@ export declare function buildProjectDetail(snap: Snapshot, key: string): Project
 export declare function buildMemoryPage(snap: Snapshot, key: string, query: MemoryQuery): MemoryPage | null;
 /** Substring search over content and tags across every project; it reads the snapshot and never touches recall. */
 export declare function buildSearch(snap: Snapshot, text: string): SearchResult;
+export interface MemoryDetailOptions {
+    readonly snapshotId: number;
+    readonly nowMs: number;
+    readonly embedded: boolean;
+}
 /** Full detail read fresh from the store, never from the snapshot, so the drawer is current inside the coalescing window. */
-export declare function buildMemoryDetail(hippoRoot: string, tenantId: string, entry: MemoryEntry, snapshotId: number, nowMs: number, embedded: boolean): MemoryDetail;
+export declare function buildMemoryDetail(hippoRoot: string, tenantId: string, entry: MemoryEntry, options: MemoryDetailOptions): MemoryDetail;
 //# sourceMappingURL=dashboard-queries.d.ts.map

package/dist/{dashboard-queries.js → dashboard/dashboard-queries.js}

@@ -1,7 +1,6 @@
 // Read models over a snapshot: overview, project, memory page, search, and the fresh single-memory detail.
-import { calculateStrength } from './memory.js';
-import { listMemoryConflicts } from './store/conflicts.js';
-import { readEntry } from './store/entry-reads.js';
+import { calculateStrength } from '../core/memory.js';
+import { loadOpenConflictsOf } from '../store/conflicts.js';
 import { BANDS, DAY_MS, LAYERS, isLiveMemory, memoryFacts, projectIdentity, } from './dashboard-snapshot.js';
 const SERIES_DAYS = 90;
 /** The server words each delta for this range; the client re-slices the series for 7d and 90d. */
@@ -297,12 +296,8 @@ export function buildSearch(snap, text) {
 }
 function openConflictsOf(hippoRoot, tenantId, entry, nowMs) {
     const out = [];
-    for (const c of listMemoryConflicts(hippoRoot, 'open', tenantId)) {
-        if (c.memory_a_id !== entry.id && c.memory_b_id !== entry.id)
-            continue;
-        const otherId = c.memory_a_id === entry.id ? c.memory_b_id : c.memory_a_id;
-        const other = readEntry(hippoRoot, otherId, tenantId);
-        if (!other || !isLiveMemory(other))
+    for (const { conflict: c, other } of loadOpenConflictsOf(hippoRoot, tenantId, entry.id)) {
+        if (!isLiveMemory(other))
             continue;
         out.push({
             id: c.id,
@@ -319,7 +314,8 @@ function openConflictsOf(hippoRoot, tenantId, entry, nowMs) {
     return out;
 }
 /** Full detail read fresh from the store, never from the snapshot, so the drawer is current inside the coalescing window. */
-export function buildMemoryDetail(hippoRoot, tenantId, entry, snapshotId, nowMs, embedded) {
+export function buildMemoryDetail(hippoRoot, tenantId, entry, options) {
+    const { snapshotId, nowMs, embedded } = options;
     const f = memoryFacts(entry, nowMs);
     const project = projectIdentity(entry.origin_project);
     return {

package/dist/{dashboard-snapshot.d.ts → dashboard/dashboard-snapshot.d.ts}

@@ -1,13 +1,11 @@
-import { Layer as MemoryLayer, type MemoryEntry } from './memory.js';
-import type { MemoryConflict } from './store/rows.js';
+import { Layer as MemoryLayer, type ConfidenceInputs, type MemoryEntry, type StrengthInputs } from '../core/memory.js';
+import { type DashboardRow, type ExcludedCounts } from '../store/dashboard-reads.js';
+import type { MemoryConflict } from '../store/rows.js';
 import type { Band, ChipCounts, Layer, Overview, ProjectKind, ProjectSummary, ScatterGrid, ScatterPoints } from './dashboard-types.js';
-export declare const DAY_MS = 86400000;
+import { DAY_MS } from '../util/time.js';
+export { DAY_MS };
 export declare const LAYERS: readonly Layer[];
 export declare const BANDS: readonly Band[];
-/** An outside commit rebuilds the snapshot at most this often. */
-export declare const COALESCE_MS = 10000;
-/** Projected strengths track the clock, so the snapshot is rebuilt at least this often. */
-export declare const TTL_MS: number;
 /** The one predicate for "shown on the dashboard": not superseded, not archived, not quarantined. */
 export declare function isLiveMemory(entry: Pick<MemoryEntry, 'superseded_by' | 'kind' | 'scope'>): boolean;
 /** Wire key, display name and kind of a project. */
@@ -34,7 +32,7 @@ export interface MemoryFacts {
     wrong: boolean;
 }
 /** Strength now and at +7d and +30d, band, age and the confidence split for one entry at `nowMs`. */
-export declare function memoryFacts(entry: MemoryEntry, nowMs: number): MemoryFacts;
+export declare function memoryFacts(entry: StrengthInputs & ConfidenceInputs & Pick<MemoryEntry, 'layer'>, nowMs: number): MemoryFacts;
 /** One live memory as the snapshot holds it: numbers and short strings only, never the full entry. */
 export interface Fact {
     id: string;
@@ -116,7 +114,9 @@ export interface SnapshotInput {
     id: number;
     tenantId: string;
     nowMs: number;
-    entries: readonly MemoryEntry[];
+    entries: readonly DashboardRow[];
+    /** Rows counted out before `entries` was read; any entry here that is not live adds to them. */
+    excluded?: ExcludedCounts;
     openConflicts: readonly Pick<MemoryConflict, 'memory_a_id' | 'memory_b_id'>[];
     embeddedIds: ReadonlySet<string> | null;
 }

package/dist/{dashboard-snapshot.js → dashboard/dashboard-snapshot.js}

@@ -1,13 +1,11 @@
 // The dashboard's read model: one in-memory snapshot of a tenant's live memories, grouped by origin project.
 // Pure build functions plus one cache; the queries over it live in dashboard-queries.ts.
-import * as fs from 'fs';
-import { calculateStrength, confidenceFacets, netWrong, Layer as MemoryLayer } from './memory.js';
-import { isQuarantineScope } from './quarantine.js';
-import { listMemoryConflicts } from './store/conflicts.js';
-import { loadAllEntries } from './store/entry-reads.js';
-import { closeHippoDb, getHippoDbPath, openHippoDbReadOnly } from './db.js';
-import { storedVectorIds } from './vector-store.js';
-export const DAY_MS = 86_400_000;
+import { calculateStrength, facetsOf, netWrong, Layer as MemoryLayer } from '../core/memory.js';
+import { isQuarantineScope } from '../trust/quarantine.js';
+import { listMemoryConflicts } from '../store/conflicts.js';
+import { DashboardConnection, loadDashboardRows } from '../store/dashboard-reads.js';
+import { DAY_MS } from '../util/time.js';
+export { DAY_MS };
 export const LAYERS = ['buffer', 'episodic', 'semantic', 'trace'];
 // Wire order of `Band`, and the order the mockup sorts bands in.
 export const BANDS = ['pinned', 'strong', 'fading', 'atRisk'];
@@ -18,9 +16,9 @@ const BAND_AT_RISK = 3;
 const CONFIDENCE_ORDER = ['verified', 'observed', 'inferred', 'stale'];
 const HEAD_CHARS = 240;
 /** An outside commit rebuilds the snapshot at most this often. */
-export const COALESCE_MS = 10_000;
+const COALESCE_MS = 10_000;
 /** Projected strengths track the clock, so the snapshot is rebuilt at least this often. */
-export const TTL_MS = 5 * 60_000;
+const TTL_MS = 5 * 60_000;
 /** The one predicate for "shown on the dashboard": not superseded, not archived, not quarantined. */
 export function isLiveMemory(entry) {
     return !entry.superseded_by && (entry.kind === 'raw' || entry.kind === 'distilled') && !isQuarantineScope(entry.scope);
@@ -52,7 +50,7 @@ export function memoryFacts(entry, nowMs) {
     const strength = calculateStrength(entry, now);
     const strength7d = calculateStrength(entry, new Date(nowMs + 7 * DAY_MS));
     const strength30d = calculateStrength(entry, new Date(nowMs + 30 * DAY_MS));
-    const facets = confidenceFacets(entry, now);
+    const facets = facetsOf(entry, now);
     const band = entry.pinned ? BAND_PINNED : strength30d < 0.2 ? BAND_AT_RISK : strength >= 0.5 ? BAND_STRONG : BAND_FADING;
     return {
         strength,
@@ -144,30 +142,42 @@ function toFact(entry, f, project, embedded, createdMs) {
         createdMs,
     };
 }
+function tallyExcluded(entry, excluded) {
+    if (isQuarantineScope(entry.scope))
+        excluded.quarantined++;
+    else if (entry.superseded_by || entry.kind === 'superseded')
+        excluded.superseded++;
+    else if (entry.kind === 'archived')
+        excluded.archived++;
+}
+function draftIndexFor(identity, projectIndex, drafts) {
+    let p = projectIndex.get(identity.key);
+    if (p === undefined) {
+        p = drafts.length;
+        projectIndex.set(identity.key, p);
+        drafts.push(newDraft(identity));
+    }
+    return p;
+}
+function finishProject(d) {
+    d.summary.atRisk = d.summary.bands.atRisk;
+    d.summary.share = d.summary.live > 0 ? d.summary.atRisk / d.summary.live : 0;
+    d.summary.lastRetrievedDays = d.summary.live > 0 ? round1(d.lastDays) : null;
+    return { summary: d.summary, members: Int32Array.from(d.members), firstCreatedMs: d.firstCreatedMs };
+}
 /** Builds the snapshot from already-loaded rows; it touches no store, so tests can feed it directly. */
 export function buildSnapshot(input) {
     const { entries, embeddedIds, nowMs } = input;
-    const excluded = { superseded: 0, archived: 0, quarantined: 0 };
+    const excluded = { superseded: 0, archived: 0, quarantined: 0, ...input.excluded };
     const facts = [];
     const projectIndex = new Map();
     const drafts = [];
     for (const entry of entries) {
         if (!isLiveMemory(entry)) {
-            if (isQuarantineScope(entry.scope))
-                excluded.quarantined++;
-            else if (entry.superseded_by || entry.kind === 'superseded')
-                excluded.superseded++;
-            else if (entry.kind === 'archived')
-                excluded.archived++;
+            tallyExcluded(entry, excluded);
             continue;
         }
-        const identity = projectIdentity(entry.origin_project);
-        let p = projectIndex.get(identity.key);
-        if (p === undefined) {
-            p = drafts.length;
-            projectIndex.set(identity.key, p);
-            drafts.push(newDraft(identity));
-        }
+        const p = draftIndexFor(projectIdentity(entry.origin_project), projectIndex, drafts);
         const f = memoryFacts(entry, nowMs);
         const embedded = embeddedIds !== null && embeddedIds.has(entry.id);
         const parsedCreated = Date.parse(entry.created);
@@ -187,12 +197,7 @@ export function buildSnapshot(input) {
         facts.push(toFact(entry, f, p, embedded, Number.isFinite(parsedCreated) ? parsedCreated : nowMs));
     }
     const openConflicts = countOpenConflicts(facts, drafts.map((d) => d.summary), input.openConflicts);
-    const projects = drafts.map((d) => {
-        d.summary.atRisk = d.summary.bands.atRisk;
-        d.summary.share = d.summary.live > 0 ? d.summary.atRisk / d.summary.live : 0;
-        d.summary.lastRetrievedDays = d.summary.live > 0 ? round1(d.lastDays) : null;
-        return { summary: d.summary, members: Int32Array.from(d.members), firstCreatedMs: d.firstCreatedMs };
-    });
+    const projects = drafts.map(finishProject);
     const embeddedTotal = projects.reduce((sum, p) => sum + p.summary.embedded, 0);
     return {
         id: input.id,
@@ -227,82 +232,74 @@ function countOpenConflicts(facts, summaries, conflicts) {
     }
     return total;
 }
+function cacheStillServes(hit, want, wallMs) {
+    const age = wallMs - hit.builtAtMs;
+    return hit.snapshot.tenantId === want.tenantId
+        && (hit.dataVersion !== null || want.dataVersion === null)
+        && age < TTL_MS
+        && (hit.dataVersion === want.dataVersion || age < COALESCE_MS);
+}
 // Keeps ids rising between two services created in the same millisecond of one process.
 let highestIssuedId = 0;
-/** Holds one read-only connection for its commit signal (`PRAGMA data_version`) and the snapshot cache; `now` dates the strength projections, `cacheClock` ages the cache. */
-export function createSnapshotService(hippoRoot, now, cacheClock = Date.now) {
-    let db = null;
-    let cached = null;
+class SnapshotCacheService {
+    hippoRoot;
+    now;
+    cacheClock;
+    connection;
+    cached = null;
     // Wall clock, not `now`, so ids keep rising across server restarts and a client holding an old tab never sees a lower one.
-    let lastId = Math.max(Date.now(), highestIssuedId);
-    let lastEmbeddedIds;
-    const dataVersion = () => {
-        if (db === null) {
-            if (!fs.existsSync(getHippoDbPath(hippoRoot)))
-                return null;
-            db = openHippoDbReadOnly(hippoRoot);
+    lastId = Math.max(Date.now(), highestIssuedId);
+    lastEmbeddedIds;
+    constructor(hippoRoot, now, cacheClock) {
+        this.hippoRoot = hippoRoot;
+        this.now = now;
+        this.cacheClock = cacheClock;
+        this.connection = new DashboardConnection(hippoRoot);
+    }
+    build(tenantId, dv, nowMs) {
+        const rows = dv === null ? null : loadDashboardRows(this.hippoRoot, tenantId);
+        const openConflicts = dv === null ? [] : listMemoryConflicts(this.hippoRoot, 'open', tenantId);
+        this.lastId += 1;
+        highestIssuedId = Math.max(highestIssuedId, this.lastId);
+        // After loadDashboardRows, whose writable open has run any pending migration and legacy embeddings.json import.
+        this.lastEmbeddedIds = this.connection.embeddedIds();
+        return buildSnapshot({ id: this.lastId, tenantId, nowMs, entries: rows?.live ?? [], excluded: rows?.excluded, openConflicts, embeddedIds: this.lastEmbeddedIds });
+    }
+    get(tenantId, fresh = false) {
+        const nowMs = this.now();
+        // A frozen eval clock (HIPPO_FAKE_NOW) would never age the cache, so reuse is timed on its own clock.
+        const wallMs = this.cacheClock();
+        // Read before the build, so a commit that lands during it shows on the next read.
+        const dv = this.connection.dataVersion();
+        const hit = this.cached;
+        if (hit !== null && !fresh) {
+            if (cacheStillServes(hit, { tenantId, dataVersion: dv }, wallMs))
+                return hit.snapshot;
         }
-        // SAFETY: PRAGMA data_version returns one row with that single integer column.
-        const row = db.prepare('PRAGMA data_version').get();
-        return row.data_version;
-    };
-    // No database means no vectors; a store not yet on schema v52 has no table to count, so coverage is unknown.
-    const readEmbeddedIds = () => {
-        if (db === null)
-            return new Set();
-        // SAFETY: sqlite_master rows carry a text name; the query only tests presence.
-        const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'memory_vectors'").get();
-        return table === undefined ? null : storedVectorIds(db);
-    };
-    const build = (tenantId, dv, nowMs) => {
-        const entries = dv === null ? [] : loadAllEntries(hippoRoot, tenantId);
-        const openConflicts = dv === null ? [] : listMemoryConflicts(hippoRoot, 'open', tenantId);
-        lastId += 1;
-        highestIssuedId = Math.max(highestIssuedId, lastId);
-        // After loadAllEntries, whose writable open has run any pending migration and legacy embeddings.json import.
-        lastEmbeddedIds = readEmbeddedIds();
-        return buildSnapshot({ id: lastId, tenantId, nowMs, entries, openConflicts, embeddedIds: lastEmbeddedIds });
-    };
-    return {
-        get(tenantId, fresh = false) {
-            const nowMs = now();
-            // A frozen eval clock (HIPPO_FAKE_NOW) would never age the cache, so reuse is timed on its own clock.
-            const wallMs = cacheClock();
-            // Read before the build, so a commit that lands during it shows on the next read.
-            const dv = dataVersion();
-            const hit = cached;
-            if (hit !== null && !fresh) {
-                const age = wallMs - hit.builtAtMs;
-                const reusable = hit.snapshot.tenantId === tenantId
-                    && (hit.dataVersion !== null || dv === null)
-                    && age < TTL_MS
-                    && (hit.dataVersion === dv || age < COALESCE_MS);
-                if (reusable)
-                    return hit.snapshot;
-            }
-            const snapshot = build(tenantId, dv, nowMs);
-            cached = { snapshot, dataVersion: dv, builtAtMs: wallMs };
-            return snapshot;
-        },
-        invalidate() {
-            cached = null;
-        },
-        currentId() {
-            return lastId;
-        },
-        embeddedIds() {
-            if (lastEmbeddedIds !== undefined)
-                return lastEmbeddedIds;
-            dataVersion();
-            return readEmbeddedIds();
-        },
-        close() {
-            if (db !== null)
-                closeHippoDb(db);
-            db = null;
-            cached = null;
-            lastEmbeddedIds = undefined;
-        },
-    };
+        const snapshot = this.build(tenantId, dv, nowMs);
+        this.cached = { snapshot, dataVersion: dv, builtAtMs: wallMs };
+        return snapshot;
+    }
+    invalidate() {
+        this.cached = null;
+    }
+    currentId() {
+        return this.lastId;
+    }
+    embeddedIds() {
+        if (this.lastEmbeddedIds !== undefined)
+            return this.lastEmbeddedIds;
+        this.connection.dataVersion();
+        return this.connection.embeddedIds();
+    }
+    close() {
+        this.connection.close();
+        this.cached = null;
+        this.lastEmbeddedIds = undefined;
+    }
+}
+/** Holds one read-only connection for its commit signal (`PRAGMA data_version`) and the snapshot cache; `now` dates the strength projections, `cacheClock` ages the cache. */
+export function createSnapshotService(hippoRoot, now, cacheClock = Date.now) {
+    return new SnapshotCacheService(hippoRoot, now, cacheClock);
 }
 //# sourceMappingURL=dashboard-snapshot.js.map