hippo-memory 1.72.0 → 2.1.0

package/dist/store/dormant.d.ts

@@ -1,12 +1,14 @@
-/** Dormant memories: what sleep does with a faded memory instead of deleting it (config `dormant.enabled`; `retentionDays` bounds how long one is kept).
- * Content stays in `dormant_memories` (schema v44) and the `memories` row goes, so every reader of `memories` stops seeing it, as if deleted.
- * Not the raw archive (`raw_archive`, `archiveRawMemory`), which keeps metadata only. db-taking helpers leave the handle and transaction to the caller. */
+/** Dormant memories: what sleep does with a faded memory instead of deleting it (config `dormant.enabled`;
+ * `retentionDays` bounds how long one is kept). Content stays in `dormant_memories` (schema v44) and the `memories` row
+ * goes, so every reader of `memories` stops seeing it, as if deleted. Not the raw archive (`raw_archive`,
+ * `archiveRawMemory`), which keeps metadata only. db-taking helpers leave the handle and transaction to the caller. */
 import { type DatabaseSyncLike } from '../db/index.js';
 import type { MemoryEntry } from '../core/memory.js';
 import type { SqlFragment } from './rule-sql.js';
 import type { WriteBudget } from '../util/write-budget.js';
-/** Why a memory went dormant: sleep's decay pass, an imported agent memory whose note was deleted, `hippo projects repair`
- * splitting a two-project merge, or `hippo audit repair` setting aside an automatic memory with a certain defect. */
+/** Why a memory went dormant: sleep's decay pass, an imported agent memory whose note was deleted, `hippo projects
+ * repair` splitting a two-project merge, or `hippo audit repair` setting aside an automatic memory with a certain
+ * defect. */
 export type DormantReason = 'decay' | 'source-deleted' | 'project-repair' | 'quality-repair';
 /** One memory that sleep is moving out of active memory into the dormant store. */
 export interface DormantMove {
@@ -38,7 +40,8 @@ export interface ListDormantOpts {
     /** Maximum rows returned, newest first. Default 20. */
     limit?: number;
 }
-/** Insert (or refresh) the dormant snapshot for `move.entry`; the caller deletes the `memories` row in the same transaction. */
+/** Insert (or refresh) the dormant snapshot for `move.entry`; the caller deletes the `memories` row in the same
+ * transaction. */
 export declare function insertDormantRow(db: DatabaseSyncLike, move: DormantMove): void;
 /** A dormant memory's stored snapshot plus when and why it went dormant. */
 export interface DormantSnapshot {
@@ -57,9 +60,11 @@ export declare function dormantSnapshotsBySourcePrefix(db: DatabaseSyncLike, ten
 export declare function replaceDormantEntry(db: DatabaseSyncLike, tenantId: string, id: string, entry: MemoryEntry): void;
 /** Delete a tenant's dormant memory. Returns false when there was none. */
 export declare function deleteDormantRow(db: DatabaseSyncLike, tenantId: string, id: string): boolean;
-/** Deletes the tenant's dormant copies of a rejected digest whose snapshot scope `inReach` admits, so the value cannot linger; returns their ids. */
+/** Deletes the tenant's dormant copies of a rejected digest whose snapshot scope `inReach` admits, so the value cannot
+ * linger; returns their ids. */
 export declare function purgeDormantByDigest(db: DatabaseSyncLike, tenantId: string, digest: string, inReach: (scope: string | null) => boolean): string[];
-/** Deletes for good every memory that went dormant before `cutoffIso`, on one handle; returns how many went, or under `dryRun` how many would. */
+/** Deletes for good every memory that went dormant before `cutoffIso`, on one handle; returns how many went, or under
+ * `dryRun` how many would. */
 export declare function expireDormantBefore(hippoRoot: string, cutoffIso: string, opts: {
     dryRun: boolean;
     budget: WriteBudget;
@@ -69,7 +74,8 @@ export declare function expireDormantBefore(hippoRoot: string, cutoffIso: string
 export declare function loadDormantMemories(hippoRoot: string, tenantId: string, opts?: ListDormantOpts, admit?: SqlFragment): DormantMemory[];
 /** Whether a tenant holds a dormant memory with this id whose scope `admit` passes, read on a handle of its own. */
 export declare function holdsDormantMemory(hippoRoot: string, tenantId: string, id: string, admit?: SqlFragment): boolean;
-/** One restore as the store applies it. The two functions are the caller's policy over plain rows; neither is handed the handle. */
+/** One restore as the store applies it. The two functions are the caller's policy over plain rows; neither is handed
+ * the handle. */
 export interface DormantRestore {
     readonly tenantId: string;
     readonly id: string;
@@ -89,7 +95,8 @@ export type DormantRestoreOutcome = {
 } | {
     readonly status: 'active';
 };
-/** Brings one dormant memory back on a single handle: the live row, the dormant delete and the audit row commit together, then its mirrors are written. */
+/** Brings one dormant memory back on a single handle: the live row, the dormant delete and the audit row commit
+ * together, then its mirrors are written. */
 export declare function restoreDormantMemory(hippoRoot: string, restore: DormantRestore): DormantRestoreOutcome;
 /** One permanent delete of a dormant memory. */
 export interface DormantForget {
@@ -100,6 +107,7 @@ export interface DormantForget {
     /** The scopes this caller may touch; a row outside them reads as missing. */
     readonly admit: SqlFragment;
 }
-/** Deletes a tenant's dormant memory for good and writes its `forget` audit row, on a single handle; false when it holds none `admit` passes. */
+/** Deletes a tenant's dormant memory for good and writes its `forget` audit row, on a single handle; false when it
+ * holds none `admit` passes. */
 export declare function forgetDormantMemory(hippoRoot: string, forget: DormantForget): boolean;
 //# sourceMappingURL=dormant.d.ts.map

package/dist/store/dormant.js

@@ -1,6 +1,7 @@
-/** Dormant memories: what sleep does with a faded memory instead of deleting it (config `dormant.enabled`; `retentionDays` bounds how long one is kept).
- * Content stays in `dormant_memories` (schema v44) and the `memories` row goes, so every reader of `memories` stops seeing it, as if deleted.
- * Not the raw archive (`raw_archive`, `archiveRawMemory`), which keeps metadata only. db-taking helpers leave the handle and transaction to the caller. */
+/** Dormant memories: what sleep does with a faded memory instead of deleting it (config `dormant.enabled`;
+ * `retentionDays` bounds how long one is kept). Content stays in `dormant_memories` (schema v44) and the `memories` row
+ * goes, so every reader of `memories` stops seeing it, as if deleted. Not the raw archive (`raw_archive`,
+ * `archiveRawMemory`), which keeps metadata only. db-taking helpers leave the handle and transaction to the caller. */
 import { closeHippoDb, openHippoDb, withWriteScope, withWriteScopeOr } from '../db/index.js';
 import { onHandle } from './open.js';
 import { rejectionDigest } from './rejection.js';
@@ -13,7 +14,8 @@ import { audit, auditRejectionRefusal } from './audit-event.js';
 import { entryIdTakenAt } from './entry-reads.js';
 import { writeEntryDbOnly, writeEntryMirrors } from './entry-writes.js';
 const DEFAULT_LIST_LIMIT = 20;
-/** Insert (or refresh) the dormant snapshot for `move.entry`; the caller deletes the `memories` row in the same transaction. */
+/** Insert (or refresh) the dormant snapshot for `move.entry`; the caller deletes the `memories` row in the same
+ * transaction. */
 export function insertDormantRow(db, move) {
     db.prepare(`
     INSERT INTO dormant_memories (tenant_id, id, content, entry_json, reason, strength, dormant_at)
@@ -24,15 +26,25 @@ export function insertDormantRow(db, move) {
       reason = excluded.reason,
       strength = excluded.strength,
       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);
+  `).run(move.entry.tenant_id, move.entry.id, move.entry.content, JSON.stringify(move.entry), move.reason, move.strength, move.dormantAt);
 }
-/** Parse a stored snapshot back into a MemoryEntry, or null when the row no longer matches it (edited by hand, or truncated). */
+function toCurrentEntry({ tenantId, summary_dirty, tenant_id, ...rest }) {
+    return {
+        ...rest,
+        tenant_id: tenant_id ?? tenantId ?? '',
+        summary_dirty: summary_dirty === true || summary_dirty === 1,
+    };
+}
+/** Parse a stored snapshot back into a MemoryEntry, or null when the row no longer matches it (edited by hand, or
+ * truncated). */
 function parseSnapshot(row) {
     try {
         // SAFETY: entry_json is only written by insertDormantRow from a MemoryEntry;
         // the id / tenant / content checks below reject a row edited out of shape.
-        const entry = JSON.parse(row.entry_json);
-        if (entry.id !== row.id || entry.tenantId !== row.tenant_id || entry.content !== row.content) {
+        // SAFETY: entry_json came from JSON.stringify of a MemoryEntry (2.0) or a 1.x one; the checks below reject a row
+        // edited out of shape.
+        const entry = toCurrentEntry(JSON.parse(row.entry_json));
+        if (entry.id !== row.id || entry.tenant_id !== row.tenant_id || entry.content !== row.content) {
             warnDamagedColumn({ table: 'dormant_memories', id: row.id, column: 'entry_json' }, 'wrong shape');
             return null;
         }
@@ -57,21 +69,27 @@ function rowToDormantMemory(row) {
     };
 }
 // The snapshot's scope as a `scope` column, so recall-scope's SQL fragments read it as they read memories.scope.
-const DORMANT_WITH_SCOPE = `(SELECT *, CASE WHEN json_valid(entry_json) THEN json_extract(entry_json, '$.scope') END AS scope FROM dormant_memories)`;
+const DORMANT_WITH_SCOPE = `(SELECT *, CASE WHEN json_valid(entry_json) THEN json_extract(entry_json, '$.scope') END ` +
+    `AS scope FROM dormant_memories)`;
 const EVERY_SCOPE = { sql: '1', params: [] };
 /** A tenant's dormant memories whose scope `admit` passes, newest first, optionally filtered by search terms. */
 function listDormantRows(db, tenantId, opts = {}, admit = EVERY_SCOPE) {
-    const terms = (opts.query ?? '').trim().split(/\s+/).filter((t) => t.length > 0);
+    const terms = (opts.query ?? '')
+        .trim()
+        .split(/\s+/)
+        .filter((t) => t.length > 0);
     const limit = opts.limit !== undefined && Number.isFinite(opts.limit) && opts.limit >= 1
         ? Math.floor(opts.limit)
         : DEFAULT_LIST_LIMIT;
     const termClauses = terms.map(() => ` AND content LIKE ? ESCAPE '\\'`).join('');
     // SAFETY: rows' shape matches the seven columns named in the SELECT.
-    const rows = db.prepare(`SELECT tenant_id, id, content, entry_json, reason, strength, dormant_at
+    const rows = db
+        .prepare(`SELECT tenant_id, id, content, entry_json, reason, strength, dormant_at
        FROM ${DORMANT_WITH_SCOPE}
       WHERE tenant_id = ? AND ${admit.sql}${termClauses}
       ORDER BY dormant_at DESC, id ASC
-      LIMIT ?`).all(tenantId, ...admit.params, ...terms.map((t) => `%${escapeLike(t)}%`), limit);
+      LIMIT ?`)
+        .all(tenantId, ...admit.params, ...terms.map((t) => `%${escapeLike(t)}%`), limit);
     return rows.map(rowToDormantMemory);
 }
 /** A tenant's stored dormant snapshot, or null when it has none with that id (another tenant's id reads as absent). */
@@ -91,10 +109,12 @@ export function listDormantSnapshots(db, tenantId) {
 /** Readable snapshots whose entry's source starts with `prefix`; a malformed snapshot is passed over, not an error. */
 export function dormantSnapshotsBySourcePrefix(db, tenantId, prefix) {
     // SAFETY: rows' shape matches the seven columns named in the SELECT.
-    const rows = db.prepare(`SELECT tenant_id, id, content, entry_json, reason, strength, dormant_at
+    const rows = db
+        .prepare(`SELECT tenant_id, id, content, entry_json, reason, strength, dormant_at
        FROM dormant_memories
       WHERE tenant_id = ?
-        AND CASE WHEN json_valid(entry_json) THEN json_extract(entry_json, '$.source') END LIKE ? ESCAPE '\\'`).all(tenantId, `${escapeLike(prefix)}%`);
+        AND CASE WHEN json_valid(entry_json) THEN json_extract(entry_json, '$.source') END LIKE ? ESCAPE '\\'`)
+        .all(tenantId, `${escapeLike(prefix)}%`);
     return rows.flatMap((row) => toSnapshot(row) ?? []).filter((s) => String(s.entry.source).startsWith(prefix));
 }
 function toSnapshot(row) {
@@ -108,14 +128,17 @@ export function replaceDormantEntry(db, tenantId, id, entry) {
 }
 /** Whether a tenant has a dormant memory with this id whose scope `admit` passes (snapshot readable or not). */
 function hasDormantRow(db, tenantId, id, admit = EVERY_SCOPE) {
-    return db.prepare(`SELECT 1 FROM ${DORMANT_WITH_SCOPE} WHERE tenant_id = ? AND id = ? AND ${admit.sql}`).get(tenantId, id, ...admit.params) !== undefined;
+    return (db
+        .prepare(`SELECT 1 FROM ${DORMANT_WITH_SCOPE} WHERE tenant_id = ? AND id = ? AND ${admit.sql}`)
+        .get(tenantId, id, ...admit.params) !== undefined);
 }
 /** Delete a tenant's dormant memory. Returns false when there was none. */
 export function deleteDormantRow(db, tenantId, id) {
     const result = db.prepare(`DELETE FROM dormant_memories WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
     return Number(result.changes ?? 0) > 0;
 }
-/** Deletes the tenant's dormant copies of a rejected digest whose snapshot scope `inReach` admits, so the value cannot linger; returns their ids. */
+/** Deletes the tenant's dormant copies of a rejected digest whose snapshot scope `inReach` admits, so the value cannot
+ * linger; returns their ids. */
 export function purgeDormantByDigest(db, tenantId, digest, inReach) {
     // SAFETY: rows' shape matches the three columns named in the SELECT.
     const rows = db.prepare(`SELECT id, content, CASE WHEN json_valid(entry_json) THEN json_extract(entry_json, '$.scope') END AS scope
@@ -156,7 +179,8 @@ async function expireInChunks(db, keys, cutoffIso, budget) {
     }
     return gone;
 }
-/** Deletes for good every memory that went dormant before `cutoffIso`, on one handle; returns how many went, or under `dryRun` how many would. */
+/** Deletes for good every memory that went dormant before `cutoffIso`, on one handle; returns how many went, or under
+ * `dryRun` how many would. */
 export async function expireDormantBefore(hippoRoot, cutoffIso, opts) {
     const db = openHippoDb(hippoRoot, { busyWaitMs: opts.busyWaitMs });
     try {
@@ -211,7 +235,8 @@ function restoreInWriteScope(db, restore) {
         return { status: 'restored', entry };
     });
 }
-/** Brings one dormant memory back on a single handle: the live row, the dormant delete and the audit row commit together, then its mirrors are written. */
+/** Brings one dormant memory back on a single handle: the live row, the dormant delete and the audit row commit
+ * together, then its mirrors are written. */
 export function restoreDormantMemory(hippoRoot, restore) {
     return onHandle(hippoRoot, (db) => {
         let outcome;
@@ -229,7 +254,8 @@ export function restoreDormantMemory(hippoRoot, restore) {
         return outcome;
     });
 }
-/** Deletes a tenant's dormant memory for good and writes its `forget` audit row, on a single handle; false when it holds none `admit` passes. */
+/** Deletes a tenant's dormant memory for good and writes its `forget` audit row, on a single handle; false when it
+ * holds none `admit` passes. */
 export function forgetDormantMemory(hippoRoot, forget) {
     const { tenantId, id, actor, admit } = forget;
     return onHandle(hippoRoot, (db) => {

package/dist/store/embeddings/index.d.ts

@@ -1,21 +1,25 @@
-/** The stored vector index's identity: which model and text format built it, and when a provider change means a rebuild.
- * Picking a provider and computing vectors sit in src/search/embed-memories.ts; this module only reads and writes what is stored. */
+/** The stored vector index's identity: which model and text format built it, and when a provider change means a
+ * rebuild. Picking a provider and computing vectors sit in src/search/embed-memories.ts; this module only reads and
+ * writes what is stored. */
 import { EMBEDDING_MODEL_META_KEY } from '../../db/vector-store.js';
 export { EMBEDDING_MODEL_META_KEY };
-/** Bump when `embeddingInputText` changes existing vectors; folded into the stored index identity (`embeddingIndexIdentity`) so it reindexes like a model
- * change. Format 2 = `path:*` tags excluded; format 1 (implicit, no suffix) included them. */
+/** Bump when `embeddingInputText` changes existing vectors; folded into the stored index identity
+ * (`embeddingIndexIdentity`) so it reindexes like a model change. Format 2 = `path:*` tags excluded; format 1
+ * (implicit, no suffix) included them. */
 export declare const EMBED_TEXT_FORMAT = 2;
-/** Stored-index identity for a provider id: folds `EMBED_TEXT_FORMAT` in so a model or text-format change invalidates the index. The ONE choke point for
- * compare (`embeddingModelRequiresReindex`) and save (`saveStoredEmbeddingModel`); they MUST version identically or every call reindexes. */
+/** Stored-index identity for a provider id: folds `EMBED_TEXT_FORMAT` in so a model or text-format change invalidates
+ * the index. The ONE choke point for compare (`embeddingModelRequiresReindex`) and save (`saveStoredEmbeddingModel`);
+ * they MUST version identically or every call reindexes. */
 export declare function embeddingIndexIdentity(providerId: string): string;
 /** Text embedded for an entry: content plus tags, space-joined and trimmed, minus `path:*` tags.
- * `path:*` tags derive from cwd, so identical content would embed differently per store location; path relevance is handled by `pathOverlapScore`. */
+ * `path:*` tags derive from cwd, so identical content would embed differently per store location; path relevance is
+ * handled by `pathOverlapScore`. */
 export declare function embeddingInputText(entry: {
     content: string;
     tags: string[];
 }): string;
-/** Persist the stored-index identity for `model` (see `embeddingIndexIdentity`); versioning happens here, not at call sites,
- * and must stay consistent with the compare side in `embeddingModelRequiresReindex`. */
+/** Persist the stored-index identity for `model` (see `embeddingIndexIdentity`); versioning happens here, not at call
+ * sites, and must stay consistent with the compare side in `embeddingModelRequiresReindex`. */
 export declare function saveStoredEmbeddingModel(hippoRoot: string, model: string): void;
 /** The one rebuild rule every store applies to its indexed model. */
 export declare function indexNeedsRebuild(indexed: string | null, providerId: string): boolean;

package/dist/store/embeddings/index.js

@@ -1,21 +1,25 @@
-/** The stored vector index's identity: which model and text format built it, and when a provider change means a rebuild.
- * Picking a provider and computing vectors sit in src/search/embed-memories.ts; this module only reads and writes what is stored. */
+/** The stored vector index's identity: which model and text format built it, and when a provider change means a
+ * rebuild. Picking a provider and computing vectors sit in src/search/embed-memories.ts; this module only reads and
+ * writes what is stored. */
 import { cosineOf } from '../../core/cosine.js';
 import { EMBEDDING_MODEL_META_KEY } from '../../db/vector-store.js';
 import { indexedModel, saveIndexIdentity, storedIndexState } from '../vector-index.js';
-import { errorMessage, log } from '../../util/log.js';
+import { errorMessage, log, errorFields } from '../../util/log.js';
 import { rethrowIfSqliteBlocked } from '../../util/sqlite-blocked.js';
 export { EMBEDDING_MODEL_META_KEY };
-/** Bump when `embeddingInputText` changes existing vectors; folded into the stored index identity (`embeddingIndexIdentity`) so it reindexes like a model
- * change. Format 2 = `path:*` tags excluded; format 1 (implicit, no suffix) included them. */
+/** Bump when `embeddingInputText` changes existing vectors; folded into the stored index identity
+ * (`embeddingIndexIdentity`) so it reindexes like a model change. Format 2 = `path:*` tags excluded; format 1
+ * (implicit, no suffix) included them. */
 export const EMBED_TEXT_FORMAT = 2;
-/** Stored-index identity for a provider id: folds `EMBED_TEXT_FORMAT` in so a model or text-format change invalidates the index. The ONE choke point for
- * compare (`embeddingModelRequiresReindex`) and save (`saveStoredEmbeddingModel`); they MUST version identically or every call reindexes. */
+/** Stored-index identity for a provider id: folds `EMBED_TEXT_FORMAT` in so a model or text-format change invalidates
+ * the index. The ONE choke point for compare (`embeddingModelRequiresReindex`) and save (`saveStoredEmbeddingModel`);
+ * they MUST version identically or every call reindexes. */
 export function embeddingIndexIdentity(providerId) {
     return `${providerId}#t${EMBED_TEXT_FORMAT}`;
 }
 /** Text embedded for an entry: content plus tags, space-joined and trimmed, minus `path:*` tags.
- * `path:*` tags derive from cwd, so identical content would embed differently per store location; path relevance is handled by `pathOverlapScore`. */
+ * `path:*` tags derive from cwd, so identical content would embed differently per store location; path relevance is
+ * handled by `pathOverlapScore`. */
 export function embeddingInputText(entry) {
     const tags = entry.tags.filter((t) => !t.startsWith('path:'));
     return `${entry.content} ${tags.join(' ')}`.trim();
@@ -26,12 +30,12 @@ function loadStoredEmbeddingModel(hippoRoot) {
     }
     catch (err) {
         rethrowIfSqliteBlocked(err);
-        log.debug(`stored embedding model unreadable: ${errorMessage(err)}`);
+        log.debug(`stored embedding model unreadable: ${errorMessage(err)}`, errorFields(err));
         return null;
     }
 }
-/** Persist the stored-index identity for `model` (see `embeddingIndexIdentity`); versioning happens here, not at call sites,
- * and must stay consistent with the compare side in `embeddingModelRequiresReindex`. */
+/** Persist the stored-index identity for `model` (see `embeddingIndexIdentity`); versioning happens here, not at call
+ * sites, and must stay consistent with the compare side in `embeddingModelRequiresReindex`. */
 export function saveStoredEmbeddingModel(hippoRoot, model) {
     saveIndexIdentity(hippoRoot, embeddingIndexIdentity(model));
 }
@@ -43,7 +47,10 @@ export function resolveIndexedEmbeddingModel(hippoRoot, index) {
     const storedModel = loadStoredEmbeddingModel(hippoRoot);
     if (storedModel)
         return storedModel;
-    return indexedModel({ storedModel, hasVectors: index ? Object.keys(index).length > 0 : storedIndexState(hippoRoot).hasVectors });
+    return indexedModel({
+        storedModel,
+        hasVectors: index ? Object.keys(index).length > 0 : storedIndexState(hippoRoot).hasVectors,
+    });
 }
 export function embeddingModelRequiresReindex(hippoRoot, model, index) {
     return indexNeedsRebuild(resolveIndexedEmbeddingModel(hippoRoot, index), model);

package/dist/store/entry-reads.d.ts

@@ -1,53 +1,88 @@
 import type { MemoryEntry } from '../core/memory.js';
 import { type DatabaseSyncLike } from '../db/index.js';
 export declare const TENANT_IS = "+tenant_id = ?";
-/** Read a memory entry by ID. With `tenantId` the read is tenant-scoped (cross-tenant returns null); omitted, no tenant filter is applied. */
+/** Read a memory entry by ID. With `tenantId` the read is tenant-scoped (cross-tenant returns null); omitted, no
+ * tenant filter is applied. */
 export declare function readEntry(hippoRoot: string, id: string, tenantId?: string): MemoryEntry | null;
-/** Answers whether a tenant's rows in this store hold an id: `ids` are looked up now, one query per chunk, and any other id on its first ask. */
-export declare function heldIdLookup(hippoRoot: string, tenantId: string, ids: readonly string[]): (id: string) => boolean;
-/** Rows by id on the caller's handle, one query per chunk; an id missing or in another tenant is absent from the map. */
+/** Rows by id on the caller's handle, one query per chunk; an
+ * id missing or in another tenant is absent from the map. */
 export declare function selectEntriesByIds(db: DatabaseSyncLike, ids: readonly string[], tenantId?: string): Map<string, MemoryEntry>;
 /** Direct children of each parent, one query per chunk; each list is in `created ASC, id ASC` order. */
 export declare function selectChildrenByParent(db: DatabaseSyncLike, parentIds: readonly string[], tenantId?: string): Map<string, MemoryEntry[]>;
-/** Batched lookup, capped at 500 ids per call to keep IN(?,?,...) within SQLite limits; tenant filter enforced when `tenantId` is passed. */
+/** Batched lookup, capped at 500 ids per call to keep IN(?,?,...) within SQLite limits; tenant filter enforced when
+ * `tenantId` is passed. */
 export declare function loadEntriesByIds(hippoRoot: string, ids: readonly string[], tenantId?: string): MemoryEntry[];
 /** All `kind='raw'` rows for a session, tenant-scoped, oldest-first, excluding superseded; `[]` for an empty sessionId.
- * With `cap`, the NEWEST rows are loaded (DESC LIMIT, reversed client-side); ASC + LIMIT would drop the newest and break fresh-tail in assemble. */
+ * With `cap`, the NEWEST rows are loaded (DESC LIMIT, reversed client-side); ASC + LIMIT would drop the newest and
+ * break fresh-tail in assemble. */
 export declare function loadSessionRawMemories(hippoRoot: string, sessionId: string, tenantId?: string, cap?: number, origins?: readonly string[]): MemoryEntry[];
-/** Pre-cap, scope-aware row count for a session, so `assemble` reports the full size without leaking rows the caller could not load. Mirrors
- * `passesScopeFilterForRecall`'s default-deny: explicit scope matches exactly, none admits only `ownScope`. `tenantId` undefined counts cross-tenant. */
+/** Pre-cap, scope-aware row count for a session, so `assemble` reports the full size without leaking rows the caller
+ * could not load. Mirrors
+ * `passesScopeFilterForRecall`'s default-deny: explicit scope matches exactly, none admits only `ownScope`.
+ * `tenantId` undefined counts cross-tenant. */
 export declare function countSessionRawMemories(hippoRoot: string, sessionId: string, tenantId?: string, scope?: string, ownScope?: string, origins?: readonly string[]): number;
-/** Last N kind='raw' memories by `created` desc, tenant-scoped, max 200; pass `sessionId` or concurrent sessions show up in each other's fresh tail.
- * The tenant-wide shape is discouraged: `api.recall` throws `RecallContractError` for it when `HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL=1`. */
+/** Last N kind='raw' memories by `created` desc, tenant-scoped, max 200; pass
+ * `sessionId` or concurrent sessions show up in each other's fresh tail. The
+ * tenant-wide shape is discouraged: `api.recall` throws `RecallContractError`
+ * for it when `HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL=1`. */
 export declare function loadFreshRawMemories(hippoRoot: string, count: number, tenantId?: string, sessionId?: string, origins?: readonly string[]): MemoryEntry[];
-/** Load all entries from SQLite; omitting `tenantId` yields all rows (legacy). Recall paths that surface results to a user MUST pass a resolved tenant. */
+/** Load all entries from SQLite; omitting `tenantId` yields all rows (legacy). Recall paths that surface results to
+ * a user MUST pass a resolved tenant. */
 export declare function loadAllEntries(hippoRoot: string, tenantId?: string): MemoryEntry[];
-/** Every tenant's memory ids in loadAllEntries' order, for a caller that reads the rows a page at a time instead of holding them all. */
+/** Every tenant's memory ids in loadAllEntries' order, for a caller that reads the rows a page at a time instead of
+ * holding them all. */
 export declare function loadAllEntryIds(hippoRoot: string): string[];
 /** How many memory rows the store holds across every tenant. */
 export declare function countAllEntries(hippoRoot: string): number;
-/** A superset, in loadAllEntries' order, of the rows whose lowercased content holds any of `tokens` or whose lowercased tags hold `tag`.
+/** A superset, in loadAllEntries' order, of the rows whose lowercased content holds any of `tokens` or whose lowercased
+ * tags hold `tag`.
  * The caller re-checks each row exactly; this only spares decoding rows that cannot match. */
 export declare function loadEntriesMentioning(hippoRoot: string, tokens: readonly string[], tag: string, tenantId?: string): MemoryEntry[];
 export interface EntryTextKey {
     id: string;
-    tenantId: string;
+    tenant_id: string;
     content: string;
     source: string;
 }
-/** Every tenant's rows in loadAllEntries' order, with only the columns that say whether another store already holds each. */
-export declare function loadEntryTextKeys(hippoRoot: string): EntryTextKey[];
+/** The rows in loadAllEntries' order (every tenant unless one is named), with only the columns that say whether
+ * another store already holds each. */
+export declare function loadEntryTextKeys(hippoRoot: string, tenantId?: string): EntryTextKey[];
 export interface EntriesWithBase {
     entries: MemoryEntry[];
     base: {
         get(id: string): MemoryEntry | undefined;
     };
 }
-/** Every entry plus a by-id lookup of each as loaded, rebuilt from its row on first use, so no deep copy of the store is kept. */
+/** Every entry plus a by-id lookup of each as loaded, rebuilt from its row on first use, so no deep copy of the
+ * store is kept. */
 export declare function loadAllEntriesWithBase(hippoRoot: string): EntriesWithBase;
+/** Where a page stopped: the `created`, `id` of its last row, in loadAllEntries' order. */
+export interface EntryCursor {
+    created: string;
+    id: string;
+}
+export interface EntryPage {
+    entries: MemoryEntry[];
+    /** The cursor that reads the page after this one, or null when this was the last. */
+    next: EntryCursor | null;
+}
+/** Up to `limit` rows in loadAllEntries' order, starting after `after`; omitting `tenantId` reads every tenant. */
+export declare function loadEntriesPage(hippoRoot: string, tenantId: string | undefined, page: {
+    limit: number;
+    after?: EntryCursor;
+}): EntryPage;
 /** Every memory row on an open connection, so a caller can read inside its own transaction. */
 export declare function selectAllEntries(db: DatabaseSyncLike, tenantId?: string): MemoryEntry[];
-/** Live rows whose source starts with `prefix`, on the caller's handle; LIKE folds case, so the prefix is checked again exactly. */
+/** The columns a text match needs, for every row of a tenant in loadAllEntries' order: callers read whole rows only
+ * for the ids that match. */
+export declare function selectTenantTexts(db: DatabaseSyncLike, tenantId: string): Array<{
+    id: string;
+    content: string;
+    source: string;
+    scope: string | null;
+}>;
+/** Live rows whose source starts with `prefix`, on the caller's
+ * handle; LIKE folds case, so the prefix is checked again exactly. */
 export declare function selectLiveEntriesBySourcePrefix(db: DatabaseSyncLike, tenantId: string, prefix: string): MemoryEntry[];
 export declare function loadContentsWithTag(hippoRoot: string, tenantId: string, tag: string, origins?: readonly string[]): string[];
 export interface VaultRawRow {
@@ -56,7 +91,8 @@ export interface VaultRawRow {
     tags_json: string;
     scope: string | null;
 }
-/** Live raw rows whose artifact_ref matches a LIKE pattern, for one tenant; the store is set up first when it is new. */
+/** Live raw rows whose artifact_ref matches a LIKE pattern,
+ * for one tenant; the store is set up first when it is new. */
 export declare function loadVaultRawRows(hippoRoot: string, likeParam: string, tenantId: string): VaultRawRow[];
 export interface PreviewRow {
     id: string;
@@ -81,7 +117,8 @@ export declare function objectMemoryRowsAt(db: DatabaseSyncLike): Array<{
     memory_id: string;
     status: string;
 }>;
-/** Live rows of a tenant whose source does not start with `sourcePrefix`; `origins` (global store only) limits them to user-global rows and those projects. */
+/** Live rows of a tenant whose source does not start with `sourcePrefix`; `origins` (global store only) limits them
+ * to user-global rows and those projects. */
 export declare function selectRowsOutsideSourcePrefixAt(db: DatabaseSyncLike, tenantId: string, sourcePrefix: string, origins: readonly string[] | null): Array<{
     id: string;
     content: string;
@@ -90,6 +127,20 @@ export declare function selectRowsOutsideSourcePrefixAt(db: DatabaseSyncLike, te
 /** Content of a tenant's live rows written by `source` and tagged `tag` that no extraction produced,
  * in loadAllEntries' order and in every scope; `exceptSessionId` drops one session's own rows. */
 export declare function loadLiveContentsBySourceAndTag(hippoRoot: string, tenantId: string, source: string, tag: string, exceptSessionId: string): string[];
-/** Every tenant's distilled rows nothing has superseded, in loadAllEntries' order: the rows that can be each other's duplicate. */
+/** Every tenant's distilled rows nothing has superseded, in
+ * loadAllEntries' order: the rows that can be each other's duplicate. */
 export declare function loadCurrentDistilledEntries(hippoRoot: string): MemoryEntry[];
+/** Row traits any one of which lets a row through loadEntriesWithSignals. */
+export interface EntrySignals {
+    tags: readonly string[];
+    sourcePrefix: string;
+    minRetrievals: number;
+    valences: readonly string[];
+}
+/** Rows holding at least one signal, in loadAllEntries' order; omitting `tenantId` reads every tenant. A superset:
+ * callers re-check each row. */
+export declare function loadEntriesWithSignals(hippoRoot: string, signals: EntrySignals, tenantId?: string): MemoryEntry[];
+/** A tenant's rows from `origins` that nothing superseded and
+ * that are neither raw nor archived, in loadAllEntries' order. */
+export declare function loadCurrentEntriesFromOrigins(hippoRoot: string, tenantId: string, origins: readonly string[]): MemoryEntry[];
 //# sourceMappingURL=entry-reads.d.ts.map