hippo-memory 1.70.0 → 1.71.0

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

@@ -1,41 +1,17 @@
-/**
- * Pluggable embedding providers for Hippo.
- *
- * The local `@huggingface/transformers` path stays the zero-DEPENDENCY DEFAULT. Opt-in
- * API providers (OpenAI / Voyage / Cohere) let a user bring a frontier embedder
- * (e.g. text-embedding-3-large) for frontier-class retrieval. They use the native
- * `fetch` global (Node >= 22.16, see package.json engines; NO new dependency) and
- * read their key from a conventional env var. The provider is selected by
- * `config.embeddings.provider` (default `'local'`).
- *
- * Design contract:
- *   - Local provider `id` is the BARE model string; the STORED identity adds a `#t<N>`
- *     embed-text-format suffix (`embeddingIndexIdentity`), so older stores reindex once:
- *     their vectors were computed over path-contaminated text.
- *   - API provider `id` is `${kind}:${model}`; switching to/from an API embedder
- *     (or a dimension change) flips the identity and triggers the existing
- *     reindex-on-change path.
- *   - `resolveEmbeddingProvider` throws on an invalid config (unknown provider,
- *     bad apiBaseUrl); `embedMemory` turns that into a warning. `isAvailable()` is provider-aware
- *     (local -> dependency installed; api -> key present). `embed()` MAY throw on
- *     a hard transport/auth failure so a reindex can abort atomically; hot paths
- *     wrap it and fall back to BM25.
- *
- * The exact request/response shapes for the API providers are documented from each
- * vendor's public embeddings API; they are unit-tested here against a mocked
- * `fetch` and are integration-verified in Workstream C (real API calls are
- * egress-blocked in the build sandbox).
- */
+/** Pluggable embedding providers; local `@huggingface/transformers` is the zero-dependency default, OpenAI / Voyage / Cohere are opt-in via native `fetch`.
+ * Local `id` is the bare model string, API `id` is `${kind}:${model}`; the stored identity adds `#t<N>` (`embeddingIndexIdentity`), so changes reindex.
+ * `embed()` MAY throw on hard transport/auth failure so a reindex aborts atomically; hot paths wrap it and fall back to BM25. */
 import { type EmbeddingRole } from './local.js';
 export type EmbeddingProviderKind = 'local' | 'openai' | 'voyage' | 'cohere';
 export declare const API_PROVIDER_KINDS: readonly EmbeddingProviderKind[];
+export interface EmbedCallOptions {
+    /** Ends the whole call when it aborts, every batch and retry included. The local provider runs in process and ignores it. */
+    signal?: AbortSignal;
+}
 export interface EmbeddingProvider {
     readonly kind: EmbeddingProviderKind;
     readonly model: string;
-    /**
-     * Identity recorded in DB meta to drive reindex-on-change.
-     * local -> bare model string (back-compat); api -> `${kind}:${model}`.
-     */
+    /** Identity recorded in DB meta to drive reindex-on-change: bare model string for local, `${kind}:${model}` for api. */
     readonly id: string;
     /** Known fixed output dimension, if any (undefined for local / unknown). */
     readonly dimensions?: number;
@@ -43,12 +19,9 @@ export interface EmbeddingProvider {
     readonly keyEnv?: string;
     /** local -> dependency installed; api -> key present. NEVER throws. */
     isAvailable(): boolean;
-    /**
-     * Batch-embed. Returns one row per input in order; a row is `[]` when that
-     * single item could not be embedded. MAY throw on a hard transport/auth
-     * failure (so a reindex aborts before saving a partial index).
-     */
-    embed(texts: string[], role?: EmbeddingRole): Promise<number[][]>;
+    /** Batch-embed: one row per input in order, `[]` when that item could not be embedded.
+     * MAY throw on a hard transport/auth failure so a reindex aborts before saving a partial index. */
+    embed(texts: string[], role?: EmbeddingRole, call?: EmbedCallOptions): Promise<number[][]>;
 }
 export interface ResolveProviderOptions {
     /** Explicit model override (mirrors resolveEmbeddingModel's explicitModel). */
@@ -56,22 +29,12 @@ export interface ResolveProviderOptions {
     /** Explicit provider override (mainly for tests). */
     provider?: EmbeddingProviderKind;
 }
-/**
- * Build the active embedding provider from config (or an explicit override).
- * Never throws for a missing key — that surfaces via `isAvailable()` on the hot
- * paths and as a hard error only from the explicit `hippo embed` command. The
- * only hard throw is an invalid config (e.g. an insecure apiBaseUrl), a
- * deliberate loud failure; hot-path callers (search) wrap this in try/catch.
- */
+/** Build the active embedding provider from config (or an explicit override). A missing key never throws here (it surfaces via `isAvailable()`);
+ * only an invalid config (e.g. insecure apiBaseUrl) throws, deliberately loud, so hot-path callers wrap it. */
 export declare function resolveEmbeddingProvider(hippoRoot: string, opts?: ResolveProviderOptions): EmbeddingProvider;
-/**
- * The reindex identity for the active provider. Use this (NOT resolveEmbeddingModel)
- * everywhere `embeddingModelRequiresReindex` / stored-model comparisons happen.
- */
+/** The reindex identity for the active provider; use it, NOT resolveEmbeddingModel, wherever `embeddingModelRequiresReindex` / stored-model comparisons
+ * happen. */
 export declare function resolveEmbeddingIdentity(hippoRoot: string, opts?: ResolveProviderOptions): string;
-/**
- * Provider-aware availability for a store: local -> dependency installed;
- * api -> key present. Use at the call sites that decide whether to embed.
- */
+/** Provider-aware availability for a store (local: dependency installed; api: key present); use where the decision to embed is made. */
 export declare function isEmbeddingConfigured(hippoRoot: string): boolean;
 //# sourceMappingURL=provider.d.ts.map

package/dist/store/embeddings/provider.js

@@ -1,38 +1,19 @@
-/**
- * Pluggable embedding providers for Hippo.
- *
- * The local `@huggingface/transformers` path stays the zero-DEPENDENCY DEFAULT. Opt-in
- * API providers (OpenAI / Voyage / Cohere) let a user bring a frontier embedder
- * (e.g. text-embedding-3-large) for frontier-class retrieval. They use the native
- * `fetch` global (Node >= 22.16, see package.json engines; NO new dependency) and
- * read their key from a conventional env var. The provider is selected by
- * `config.embeddings.provider` (default `'local'`).
- *
- * Design contract:
- *   - Local provider `id` is the BARE model string; the STORED identity adds a `#t<N>`
- *     embed-text-format suffix (`embeddingIndexIdentity`), so older stores reindex once:
- *     their vectors were computed over path-contaminated text.
- *   - API provider `id` is `${kind}:${model}`; switching to/from an API embedder
- *     (or a dimension change) flips the identity and triggers the existing
- *     reindex-on-change path.
- *   - `resolveEmbeddingProvider` throws on an invalid config (unknown provider,
- *     bad apiBaseUrl); `embedMemory` turns that into a warning. `isAvailable()` is provider-aware
- *     (local -> dependency installed; api -> key present). `embed()` MAY throw on
- *     a hard transport/auth failure so a reindex can abort atomically; hot paths
- *     wrap it and fall back to BM25.
- *
- * The exact request/response shapes for the API providers are documented from each
- * vendor's public embeddings API; they are unit-tested here against a mocked
- * `fetch` and are integration-verified in Workstream C (real API calls are
- * egress-blocked in the build sandbox).
- */
+/** Pluggable embedding providers; local `@huggingface/transformers` is the zero-dependency default, OpenAI / Voyage / Cohere are opt-in via native `fetch`.
+ * Local `id` is the bare model string, API `id` is `${kind}:${model}`; the stored identity adds `#t<N>` (`embeddingIndexIdentity`), so changes reindex.
+ * `embed()` MAY throw on hard transport/auth failure so a reindex aborts atomically; hot paths wrap it and fall back to BM25. */
 import { envByName } from '../../util/env.js';
 import { getEmbedding, isEmbeddingAvailable, requireLocalPipeline, resolveEmbeddingModel, DEFAULT_EMBEDDING_MODEL, } from './local.js';
 import { loadConfig } from '../../core/config.js';
 import { errorMessage, log } from '../../util/log.js';
 import { redactSecretsStrict } from '../../util/secret-detect.js';
 import { fetchWithRetry } from '../../util/http-retry.js';
+import { readCappedJson, readCappedText } from '../../util/capped-json.js';
 const ERROR_DETAIL_CHARS = 300;
+// An error body is read for its first lines only; 4x leaves room for multi-byte text.
+const ERROR_BODY_MAX_BYTES = ERROR_DETAIL_CHARS * 4;
+// 16,384 dimensions at 32 bytes a number: four times a 4,096-dimension model.
+const EMBED_REPLY_BYTES_PER_INPUT = 512 * 1024;
+const EMBED_REPLY_BASE_BYTES = 64 * 1024;
 export const API_PROVIDER_KINDS = ['openai', 'voyage', 'cohere'];
 function isApiProviderKind(x) {
     return x === 'openai' || x === 'voyage' || x === 'cohere';
@@ -41,9 +22,8 @@ const DEFAULT_API_BATCH_SIZE = 64;
 /** Per-request timeout for API embedding calls. A provider/proxy that accepts
  *  the connection but never responds must not hang embed/recall indefinitely. */
 const REQUEST_TIMEOUT_MS = 30_000;
-// ---------------------------------------------------------------------------
-// Local provider — wraps the existing zero-dep transformers.js path.
-// ---------------------------------------------------------------------------
+// Under a caller's deadline a longer Retry-After hands the reply back at once; the remote rerankers use the same cap.
+const DEADLINE_RETRY_WAIT_CAP_MS = 2_000;
 class LocalEmbeddingProvider {
     model;
     enabled;
@@ -78,8 +58,7 @@ const API_PROVIDER_SPECS = {
         // OpenAI has no asymmetric query/passage input type for embeddings.
         buildBody: (model, texts) => ({ model, input: texts }),
         extractVectors: (json) => {
-            // SAFETY: OpenAI's documented embeddings response envelope; embedChunk
-            // validates vector count/non-emptiness against the request afterward,
+            // SAFETY: OpenAI's documented embeddings envelope; embedChunk validates vector count and non-emptiness afterward,
             // so a malformed response degrades to [] here and throws there.
             const data = json.data ?? [];
             return data.map((d) => d.embedding ?? []);
@@ -97,8 +76,7 @@ const API_PROVIDER_SPECS = {
             return body;
         },
         extractVectors: (json) => {
-            // SAFETY: Voyage's documented embeddings response envelope; embedChunk
-            // validates vector count/non-emptiness against the request afterward,
+            // SAFETY: Voyage's documented embeddings envelope; embedChunk validates vector count and non-emptiness afterward,
             // so a malformed response degrades to [] here and throws there.
             const data = json.data ?? [];
             return data.map((d) => d.embedding ?? []);
@@ -116,10 +94,8 @@ const API_PROVIDER_SPECS = {
             embedding_types: ['float'],
         }),
         extractVectors: (json) => {
-            // Cohere v2: { embeddings: { float: number[][] } }
-            // SAFETY: matches Cohere's documented v2 response envelope; embedChunk
-            // validates vector count/non-emptiness against the request afterward,
-            // so a malformed response degrades to [] here and throws there.
+            // Cohere v2 shape: { embeddings: { float: number[][] } }
+            // SAFETY: documented v2 envelope; embedChunk validates the vectors afterward, so a malformed response degrades to [] here and throws there.
             const emb = json.embeddings;
             return emb?.float ?? [];
         },
@@ -169,7 +145,7 @@ class ApiEmbeddingProvider {
     isAvailable() {
         return this.enabled && !!envByName(this.keyEnv)?.trim();
     }
-    async embed(texts, role) {
+    async embed(texts, role, call = {}) {
         if (texts.length === 0)
             return [];
         const key = envByName(this.keyEnv)?.trim();
@@ -181,21 +157,19 @@ class ApiEmbeddingProvider {
         const out = [];
         for (let i = 0; i < texts.length; i += this.batchSize) {
             const chunk = texts.slice(i, i + this.batchSize);
-            const vecs = await this.embedChunk(chunk, key, role);
+            const vecs = await this.embedChunk(chunk, key, role, call.signal);
             for (const v of vecs)
                 out.push(v.length > 0 ? l2normalize(v) : v);
         }
         return out;
     }
-    async embedChunk(chunk, key, role) {
+    async embedChunk(chunk, key, role, signal) {
         const spec = API_PROVIDER_SPECS[this.kind];
-        const resp = await this.postChunk(chunk, key, role);
-        const json = await this.responseJson(resp, key);
+        const resp = await this.postChunk(chunk, key, role, signal);
+        const json = await this.responseJson(resp, key, chunk.length);
         const vectors = spec.extractVectors(json);
-        // A 200 response with the wrong number of vectors (or any empty/malformed
-        // vector) is a provider/proxy contract violation, NOT a per-item miss. Throw
-        // so a reindex aborts atomically (preserving the prior usable index) and the
-        // explicit backfill surfaces it, instead of silently saving []-padded rows.
+        // A 200 with the wrong vector count (or any empty/malformed vector) is a provider contract violation, not a per-item miss:
+        // throw so a reindex aborts atomically and the explicit backfill surfaces it, instead of saving []-padded rows.
         if (vectors.length !== chunk.length) {
             throw new Error(redact(`${this.kind} embeddings returned ${vectors.length} vectors for ${chunk.length} inputs`, key));
         }
@@ -206,7 +180,7 @@ class ApiEmbeddingProvider {
         }
         return vectors;
     }
-    async postChunk(chunk, key, role) {
+    async postChunk(chunk, key, role, signal) {
         const spec = API_PROVIDER_SPECS[this.kind];
         const url = `${this.baseUrl.replace(/\/$/, '')}/${spec.path}`;
         try {
@@ -217,7 +191,13 @@ class ApiEmbeddingProvider {
                     authorization: `Bearer ${key}`,
                 },
                 body: JSON.stringify(spec.buildBody(this.model, chunk.map(redactSecretsStrict), role)),
-            }, { timeoutMs: REQUEST_TIMEOUT_MS });
+                signal,
+            }, {
+                timeoutMs: REQUEST_TIMEOUT_MS,
+                // Embedding the same text twice changes nothing on the far side, so a dropped connection or a stalled attempt is replayed.
+                retryTransport: true,
+                maxDelayMs: signal ? DEADLINE_RETRY_WAIT_CAP_MS : undefined,
+            });
         }
         catch (err) {
             const msg = errorMessage(err);
@@ -225,11 +205,11 @@ class ApiEmbeddingProvider {
         }
     }
     /** The body of an OK reply; any other status, or a body that is not JSON, throws with the key cut out. */
-    async responseJson(resp, key) {
+    async responseJson(resp, key, inputs) {
         if (!resp.ok) {
             let detail = '';
             try {
-                detail = await resp.text();
+                detail = await readCappedText(resp, ERROR_BODY_MAX_BYTES);
             }
             catch {
                 /* ignore body read error */
@@ -237,11 +217,13 @@ class ApiEmbeddingProvider {
             throw new Error(redact(`${this.kind} embeddings HTTP ${resp.status}: ${detail.slice(0, ERROR_DETAIL_CHARS)}`, key));
         }
         try {
-            return await resp.json();
+            return await readCappedJson(resp, EMBED_REPLY_BASE_BYTES + inputs * EMBED_REPLY_BYTES_PER_INPUT);
         }
         catch (err) {
             const msg = errorMessage(err);
-            throw new Error(redact(`${this.kind} embeddings returned invalid JSON: ${msg}`, key), { cause: redactedCause(err, key) });
+            throw new Error(redact(`${this.kind} embeddings returned invalid JSON: ${msg}`, key), {
+                cause: redactedCause(err instanceof Error && err.cause ? err.cause : err, key)
+            });
         }
     }
 }
@@ -273,13 +255,8 @@ function validateBaseUrl(url, fallback) {
     }
     return candidate;
 }
-/**
- * Build the active embedding provider from config (or an explicit override).
- * Never throws for a missing key — that surfaces via `isAvailable()` on the hot
- * paths and as a hard error only from the explicit `hippo embed` command. The
- * only hard throw is an invalid config (e.g. an insecure apiBaseUrl), a
- * deliberate loud failure; hot-path callers (search) wrap this in try/catch.
- */
+/** Build the active embedding provider from config (or an explicit override). A missing key never throws here (it surfaces via `isAvailable()`);
+ * only an invalid config (e.g. insecure apiBaseUrl) throws, deliberately loud, so hot-path callers wrap it. */
 export function resolveEmbeddingProvider(hippoRoot, opts = {}) {
     const cfg = readEmbeddingsConfig(hippoRoot);
     const requested = opts.provider ?? cfg.provider ?? 'local';
@@ -306,17 +283,12 @@ export function resolveEmbeddingProvider(hippoRoot, opts = {}) {
         : DEFAULT_API_BATCH_SIZE;
     return new ApiEmbeddingProvider(kind, model, baseUrl, batchSize, enabled);
 }
-/**
- * The reindex identity for the active provider. Use this (NOT resolveEmbeddingModel)
- * everywhere `embeddingModelRequiresReindex` / stored-model comparisons happen.
- */
+/** The reindex identity for the active provider; use it, NOT resolveEmbeddingModel, wherever `embeddingModelRequiresReindex` / stored-model comparisons
+ * happen. */
 export function resolveEmbeddingIdentity(hippoRoot, opts = {}) {
     return resolveEmbeddingProvider(hippoRoot, opts).id;
 }
-/**
- * Provider-aware availability for a store: local -> dependency installed;
- * api -> key present. Use at the call sites that decide whether to embed.
- */
+/** Provider-aware availability for a store (local: dependency installed; api: key present); use where the decision to embed is made. */
 export function isEmbeddingConfigured(hippoRoot) {
     try {
         return resolveEmbeddingProvider(hippoRoot).isAvailable();

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

@@ -1,13 +1,7 @@
 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.
- *
- * When `tenantId` is provided, the read is scoped to that tenant (cross-tenant
- * lookups return null). When omitted, no tenant filter is applied — preserves
- * legacy single-tenant callers and the writeEntry/readEntry round-trip.
- */
+/** 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;
 /** Ids per `IN (...)` list: far under SQLite's bound-parameter limit, with room for the tenant filter. */
 export declare const ID_CHUNK = 500;
@@ -19,60 +13,29 @@ export declare function heldIdLookup(hippoRoot: string, tenantId: string, ids: r
 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. Caps at 500 ids per call to keep the IN(?,?,...) clause
- * within SQLite limits. Tenant filter is enforced when `tenantId` is passed.
- * Used by DAG-aware recall to fetch parent summaries for a set of overflowed leaves.
- */
+/** 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 given session, tenant-scoped, returned
- * oldest-first. Used by `api.assemble` to walk a session's chronological
- * context. Excludes superseded rows.
- *
- * Cap semantics: when `cap` is provided, the NEWEST `cap` rows are loaded (DESC LIMIT server-side,
- * reversed client-side); ASC + LIMIT would drop the newest rows and break fresh-tail in assemble.
- *
- * Returns `[]` for an empty sessionId. Final order: `created ASC, id ASC`.
- */
+/** 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. */
 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. Lets `assemble` report
- * the full session size even when `rowCap` truncates the loaded window,
- * WITHOUT leaking rows the caller wouldn't have been allowed to load.
- *
- * An unscoped COUNT would let a no-scope caller infer private rows by comparing `totalRaw`
- * against `items.length`, so this SQL-encodes the default-deny rule `passesScopeFilterForRecall` applies in TS:
- *   - explicit scope passed: exact-match
- *   - no scope: `scopeAdmitSql`'s default deny, which admits `ownScope`, the caller's personal scope.
- *
- * `tenantId` is optional for back-compat. Pass `undefined` only when
- * intentionally counting cross-tenant; `assemble()` passes `ctx.tenantId`.
- */
+/** 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. When
- * `sessionId` is supplied, also constrains to a specific session — that
- * is the correct shape for "what did I just see in THIS session."
- *
- * Without `sessionId`, concurrent sessions in a tenant surface each other's rows as fresh tail;
- * pass undefined only for "anything new across the whole tenant".
- *
- * Bounded count cap at 200 — beyond that the caller should filter via
- * tags/scope rather than time-windowed recall.
- *
- * The tenant-wide shape is the back-compat default but discouraged; `api.recall` throws
- * `RecallContractError` for it when `HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL=1` is set.
- */
+/** 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.
- *
- * When `tenantId` is provided, results are scoped to that tenant. Omitting it
- * yields all rows (legacy behavior used by consolidate/autolearn etc.). 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. */
+export declare function loadAllEntryIds(hippoRoot: string): string[];
+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. */
+export declare function loadAllEntriesWithBase(hippoRoot: string): EntriesWithBase;
 /** 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. */
@@ -115,7 +78,8 @@ export declare function selectRowsOutsideSourcePrefixAt(db: DatabaseSyncLike, te
     content: string;
     source: string;
 }>;
-/** 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. */
+/** 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. */
 export declare function loadCurrentDistilledEntries(hippoRoot: string): MemoryEntry[];