hippo-memory 2.0.0 → 2.1.0

package/dist/embeddings/local.d.ts

@@ -1,4 +1,5 @@
-/** The one call this file makes on a Transformers.js feature-extraction pipeline, and the part of its tensor it reads. */
+/** The one call this file makes on a Transformers.js feature-extraction pipeline, and the part of its tensor it
+ * reads. */
 interface EmbeddingPipeline {
     (input: string, options: {
         pooling: 'cls' | 'mean';
@@ -25,7 +26,8 @@ interface TransformersModule {
     };
 }
 export declare const DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
-/** BGE was trained with CLS pooling; everything else gets mean, the sentence-transformers default, since CLS degrades mean-trained models. */
+/** BGE was trained with CLS pooling; everything else gets mean, the sentence-transformers default, since CLS
+ * degrades mean-trained models. */
 export declare function poolingFor(model: string): 'cls' | 'mean';
 /** `query` is search input, `passage` is a document being indexed; no role means no prefix on any model. */
 export type EmbeddingRole = 'query' | 'passage';
@@ -44,7 +46,8 @@ export interface LocalTransformers {
 export interface LocalEmbedder {
     isAvailable(): boolean;
     /** Throws, with the reason, when the model's pipeline cannot load: a provider-level failure, not a per-item skip.
-     * `signal` ends the wait, never the load, and only once the load is downloading: a load from disk ends soon on its own, a download may not. */
+     * `signal` ends the wait, never the load, and only once the load is downloading: a load from disk ends soon on its
+     * own, a download may not. */
     requirePipeline(model: string, signal?: AbortSignal): Promise<void>;
     /** `text`'s vector, or `[]` when the model is missing or fails; `role` adds e5-style prefixes. */
     embed(text: string, model: string, role?: EmbeddingRole): Promise<number[]>;
@@ -56,7 +59,8 @@ export declare const sharedLocalEmbedder: LocalEmbedder;
 /** Check (synchronously) if @xenova/transformers or @huggingface/transformers is installed. */
 export declare function isEmbeddingAvailable(): boolean;
 export declare function resolveEmbeddingModel(hippoRoot: string, explicitModel?: string): string;
-/** Embeds `text` with the local model, or returns `[]` when Transformers.js is missing or fails; `role` adds e5-style prefixes. */
+/** Embeds `text` with the local model, or returns `[]` when Transformers.js is missing or fails; `role` adds
+ * e5-style prefixes. */
 export declare function getEmbedding(text: string, model?: string, role?: EmbeddingRole): Promise<number[]>;
 export {};
 //# sourceMappingURL=local.d.ts.map

package/dist/embeddings/local.js

@@ -7,7 +7,8 @@ import { loadConfig } from '../core/config.js';
 import { errorFields, errorMessage, log } from '../util/log.js';
 import { createModelLoads, importTransformers, MODEL_LOAD_POLICY, resolveTransformersPackage } from './transformers.js';
 export const DEFAULT_EMBEDDING_MODEL = 'Xenova/all-MiniLM-L6-v2';
-/** BGE was trained with CLS pooling; everything else gets mean, the sentence-transformers default, since CLS degrades mean-trained models. */
+/** BGE was trained with CLS pooling; everything else gets mean, the sentence-transformers default, since CLS
+ * degrades mean-trained models. */
 export function poolingFor(model) {
     return /\bbge\b/i.test(model) ? 'cls' : 'mean';
 }
@@ -57,7 +58,8 @@ function warnLoadFailure(model, err) {
 }
 /** The model's pipeline; throws the reason it cannot load. */
 async function createPipeline(transformers, model, gates) {
-    // The package is an optional peer, so the dynamic import is typed by what this file reads; a missing export throws below.
+    // The package is an optional peer, so the dynamic import is typed by what this file reads; a missing export throws
+    // below.
     const imported = await transformers.load();
     if (!imported)
         throw new Error('no transformers package is installed');
@@ -82,7 +84,8 @@ async function createPipeline(transformers, model, gates) {
         gates.delete(model);
     }
 }
-/** Whether the load will download: remote models are allowed and no folder the package reads holds the model's ONNX files. */
+/** Whether the load will download: remote models are allowed and no folder the package reads holds the model's ONNX
+ * files. */
 function fetchesWeights(env, model) {
     if (env?.allowRemoteModels === false)
         return false;
@@ -135,11 +138,12 @@ export function resolveEmbeddingModel(hippoRoot, explicitModel) {
             return configured;
     }
     catch (err) {
-        log.warn(`embedding model config unreadable, using the default model: ${errorMessage(err)}`);
+        log.warn(`embedding model config unreadable, using the default model: ${errorMessage(err)}`, errorFields(err));
     }
     return DEFAULT_EMBEDDING_MODEL;
 }
-/** Embeds `text` with the local model, or returns `[]` when Transformers.js is missing or fails; `role` adds e5-style prefixes. */
+/** Embeds `text` with the local model, or returns `[]` when Transformers.js is missing or fails; `role` adds
+ * e5-style prefixes. */
 export function getEmbedding(text, model = DEFAULT_EMBEDDING_MODEL, role) {
     return sharedLocalEmbedder.embed(text, model, role);
 }

package/dist/embeddings/provider.d.ts

@@ -1,18 +1,23 @@
-/** 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. */
+/** 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, type LocalTransformers } 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 stops waiting only on a model download,
+    /** Ends the whole call when it aborts, every batch and retry included. The local provider stops waiting only on a
+     * model download,
      * since nothing stops a load from disk or an in-process inference. */
     signal?: AbortSignal;
 }
 export interface EmbeddingProvider {
     readonly kind: EmbeddingProviderKind;
     readonly model: string;
-    /** Identity recorded in DB meta to drive reindex-on-change: bare model string for local, `${kind}:${model}` for api. */
+    /** 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;
@@ -29,15 +34,19 @@ export interface ResolveProviderOptions {
     model?: string;
     /** Explicit provider override (mainly for tests). */
     provider?: EmbeddingProviderKind;
-    /** The Transformers.js package a local provider loads from, with its own models; the process's shared embedder when unset. */
+    /** The Transformers.js package a local provider loads from, with
+     * its own models; the process's shared embedder when unset. */
     transformers?: LocalTransformers;
 }
-/** Build the active embedding provider from config (or an explicit override). A missing key never throws here (it surfaces via `isAvailable()`);
+/** 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 it, NOT resolveEmbeddingModel, wherever `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 where the decision to embed is made. */
+/** 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/embeddings/provider.js

@@ -1,10 +1,13 @@
-/** 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. */
+/** 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 { createLocalEmbedder, resolveEmbeddingModel, sharedLocalEmbedder, DEFAULT_EMBEDDING_MODEL, } from './local.js';
 import { loadConfig } from '../core/config.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } 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';
@@ -41,7 +44,8 @@ class LocalEmbeddingProvider {
         return this.enabled && this.embedder.isAvailable();
     }
     async embed(texts, role, call = {}) {
-        // A model that cannot load fails the call, as an API outage does; items then run one at a time on the shared pipeline.
+        // A model that cannot load fails the call, as an API outage
+        // does; items then run one at a time on the shared pipeline.
         if (texts.length > 0)
             await this.embedder.requirePipeline(this.model, call.signal);
         const out = [];
@@ -97,7 +101,8 @@ const API_PROVIDER_SPECS = {
         }),
         extractVectors: (json) => {
             // 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.
+            // 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 ?? [];
         },
@@ -170,7 +175,8 @@ class ApiEmbeddingProvider {
         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 with the wrong vector count (or any empty/malformed vector) is a provider contract violation, not a per-item miss:
+        // 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));
@@ -196,14 +202,17 @@ class ApiEmbeddingProvider {
                 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.
+                // 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);
-            throw new Error(redact(`embedding request to ${this.kind} failed: ${msg}`, key), { cause: redactedCause(err, key) });
+            throw new Error(redact(`embedding request to ${this.kind} failed: ${msg}`, key), {
+                cause: redactedCause(err, key),
+            });
         }
     }
     /** The body of an OK reply; any other status, or a body that is not JSON, throws with the key cut out. */
@@ -214,7 +223,8 @@ class ApiEmbeddingProvider {
                 detail = await readCappedText(resp, ERROR_BODY_MAX_BYTES);
             }
             catch (err) {
-                log.debug(`${this.kind} embeddings error body unreadable: ${errorMessage(err)}`);
+                // The error thrown below already carries the status; the body is only extra detail.
+                log.debug(`${this.kind} embeddings error body unreadable: ${errorMessage(err)}`, errorFields(err));
             }
             throw new Error(redact(`${this.kind} embeddings HTTP ${resp.status}: ${detail.slice(0, ERROR_DETAIL_CHARS)}`, key));
         }
@@ -224,7 +234,7 @@ class ApiEmbeddingProvider {
         catch (err) {
             const msg = errorMessage(err);
             throw new Error(redact(`${this.kind} embeddings returned invalid JSON: ${msg}`, key), {
-                cause: redactedCause(err instanceof Error && err.cause ? err.cause : err, key)
+                cause: redactedCause(err instanceof Error && err.cause ? err.cause : err, key),
             });
         }
     }
@@ -248,7 +258,8 @@ function validateBaseUrl(url, fallback) {
     }
     return candidate;
 }
-/** Build the active embedding provider from config (or an explicit override). A missing key never throws here (it surfaces via `isAvailable()`);
+/** 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 = loadConfig(hippoRoot).embeddings;
@@ -263,7 +274,8 @@ export function resolveEmbeddingProvider(hippoRoot, opts = {}) {
     if (!isApiProviderKind(requested)) {
         // Fail loud on a typo'd provider rather than silently using local (which
         // would reindex with the local model and clobber the intended identity).
-        throw new Error(`Unknown embeddings.provider '${requested}'. Valid values: local, ${API_PROVIDER_KINDS.filter((k) => k !== 'local').join(', ')}.`);
+        throw new Error(`Unknown embeddings.provider '${requested}'. Valid values: local, ` +
+            `${API_PROVIDER_KINDS.filter((k) => k !== 'local').join(', ')}.`);
     }
     const kind = requested;
     const spec = API_PROVIDER_SPECS[kind];
@@ -277,19 +289,21 @@ 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 it, NOT resolveEmbeddingModel, wherever `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 where the decision to embed is made. */
+/** 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();
     }
     catch (err) {
         // An invalid embedding config must not crash the best-effort ingestion guard, so it reads as not configured.
-        log.debug(`embedding config unusable: ${errorMessage(err)}`);
+        log.warnThenDebug(`embedding-config-unusable:${hippoRoot}`, `embedding config unusable: ${errorMessage(err)}`, errorFields(err));
         return false;
     }
 }

package/dist/embeddings/transformers.d.ts

@@ -1,6 +1,9 @@
 export interface TransformersPackage {
     readonly name: string;
-    /** The ESM entry; a require-style import picks the CommonJS build and puts a second copy of the library, with its own ONNX sessions, in the process. */
+    /**
+     * The ESM entry; a require-style import picks the CommonJS build and puts a second copy of the library, with its own
+     * ONNX sessions, in the process.
+     */
     readonly url: string;
 }
 /** The installed package to import, or null when neither is installed. */
@@ -11,16 +14,25 @@ export declare function importTransformers<M>(): Promise<{
     readonly mod: M;
 } | null>;
 export interface ModelLoadPolicy {
-    /** How long one load may run before it counts as failed; nothing can cancel it, so it keeps running and a late model is still kept. */
+    /**
+     * How long one load may run before it counts as failed; nothing can cancel it, so it keeps running and a late model
+     * is still kept.
+     */
     readonly timeoutMs: number;
     /** How long a failure is answered from memory before the next call loads again. */
     readonly backoffMs: number;
 }
 export declare const MODEL_LOAD_POLICY: ModelLoadPolicy;
 export interface ModelLoads<T> {
-    /** The model under `key`: the loaded one, the load in flight, the failure inside its backoff window, or a new `start()`. */
+    /**
+     * The model under `key`: the loaded one, the load in flight, the failure inside its backoff window, or a new
+     * `start()`.
+     */
     load(key: string, start: () => Promise<T>): Promise<T>;
 }
-/** One load per key at a time, bounded by the policy's timeout; `onFailure` hears each failed attempt, so once per backoff window. */
+/**
+ * One load per key at a time, bounded by the policy's timeout; `onFailure` hears each failed attempt, so once per
+ * backoff window.
+ */
 export declare function createModelLoads<T>(policy: ModelLoadPolicy, onFailure?: (key: string, err: Error) => void): ModelLoads<T>;
 //# sourceMappingURL=transformers.d.ts.map

package/dist/embeddings/transformers.js

@@ -1,4 +1,5 @@
-// The optional Transformers.js package, and a bounded load of a model from it, shared by the local embedder and the cross-encoder.
+// The optional Transformers.js package, and a bounded load of a model from it, shared by the local embedder and the
+// cross-encoder.
 import { MINUTE_MS } from '../util/time.js';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
@@ -21,7 +22,8 @@ function entryUrl(name) {
         return import.meta.resolve(name);
     }
     catch {
-        // import.meta.resolve is missing under some module runners (vitest's included), so the require-based resolve stands in there.
+        // import.meta.resolve is missing under some module runners (vitest's included), so the require-based resolve stands
+        // in there.
         try {
             return pathToFileURL(_require.resolve(name)).href;
         }
@@ -41,30 +43,43 @@ export async function importTransformers() {
     catch (err) {
         // A Node error's code (ERR_MODULE_NOT_FOUND and the like) says more than its message alone.
         const code = errorCode(err);
-        throw new Error(`transformers import failed (${pkg.name}): ${code ? `${code} ` : ''}${errorMessage(err)}`, { cause: err });
+        throw new Error(`transformers import failed (${pkg.name}): ${code ? `${code} ` : ''}${errorMessage(err)}`, {
+            cause: err,
+        });
     }
 }
 // A quantized MiniLM is about 23 MB, so two minutes is a 1.5 Mbit/s link; a load from disk takes about a second.
 // The backoff matches the reranker outage warning's repeat window, so each window has one attempt and one warning.
 export const MODEL_LOAD_POLICY = { timeoutMs: 2 * MINUTE_MS, backoffMs: 5 * MINUTE_MS };
-/** One load per key at a time, bounded by the policy's timeout; `onFailure` hears each failed attempt, so once per backoff window. */
-export function createModelLoads(policy, onFailure) {
-    const loaded = new Map();
-    const inFlight = new Map();
-    const failed = new Map();
-    const attempt = (key, start) => new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(`${key} did not load within ${policy.timeoutMs / 1000} s`)), policy.timeoutMs);
+/** Runs `start` under a timeout; a model that arrives after the timeout is still handed to `onLoaded`. */
+function loadWithTimeout(key, start, timeoutMs, onLoaded) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${key} did not load within ${timeoutMs / 1000} s`)), timeoutMs);
         timer.unref();
-        Promise.resolve().then(start).then((model) => {
+        Promise.resolve()
+            .then(start)
+            .then((model) => {
             clearTimeout(timer);
-            loaded.set(key, model);
-            failed.delete(key);
+            onLoaded(model);
             resolve(model);
         }, (err) => {
             clearTimeout(timer);
             reject(err instanceof Error ? err : new Error(errorMessage(err)));
         });
     });
+}
+/**
+ * One load per key at a time, bounded by the policy's timeout; `onFailure` hears each failed attempt, so once per
+ * backoff window.
+ */
+export function createModelLoads(policy, onFailure) {
+    const loaded = new Map();
+    const inFlight = new Map();
+    const failed = new Map();
+    const attempt = (key, start) => loadWithTimeout(key, start, policy.timeoutMs, (model) => {
+        loaded.set(key, model);
+        failed.delete(key);
+    });
     return {
         load(key, start) {
             const model = loaded.get(key);
@@ -76,11 +91,13 @@ export function createModelLoads(policy, onFailure) {
             const failure = failed.get(key);
             if (failure && Date.now() < failure.until)
                 return Promise.reject(failure.error);
-            const next = attempt(key, start).catch((err) => {
+            const next = attempt(key, start)
+                .catch((err) => {
                 failed.set(key, { error: err, until: Date.now() + policy.backoffMs });
                 onFailure?.(key, err);
                 throw err;
-            }).finally(() => inFlight.delete(key));
+            })
+                .finally(() => inFlight.delete(key));
             inFlight.set(key, next);
             return next;
         },

package/dist/entry/json-hooks.d.ts

@@ -1,3 +1,3 @@
-export { installJsonHooks, resolveJsonHookPaths, uninstallJsonHooks, writeSettingsFile, type InstallResult, type JsonHookPaths } from '../hooks/json-hooks.js';
+export { installJsonHooks, resolveJsonHookPaths, uninstallJsonHooks, writeSettingsFile, type InstallResult, type JsonHookPaths, } from '../hooks/json-hooks.js';
 export { readJsonFile } from '../util/json.js';
 //# sourceMappingURL=json-hooks.d.ts.map

package/dist/entry/json-hooks.js

@@ -1,4 +1,4 @@
 // The hippo-memory/json-hooks subpath: only what the changelog publishes, so the module's other exports stay internal.
-export { installJsonHooks, resolveJsonHookPaths, uninstallJsonHooks, writeSettingsFile } from '../hooks/json-hooks.js';
+export { installJsonHooks, resolveJsonHookPaths, uninstallJsonHooks, writeSettingsFile, } from '../hooks/json-hooks.js';
 export { readJsonFile } from '../util/json.js';
 //# sourceMappingURL=json-hooks.js.map

package/dist/entry/project-identity.js

@@ -1,3 +1,4 @@
-// The hippo-memory/project-identity subpath: only what the changelog publishes, so the module's other exports stay internal.
+// The hippo-memory/project-identity subpath: only what the changelog publishes, so the module's other exports stay
+// internal.
 export { MAX_PROJECT_ALIASES, MCP_PROJECT_SCOPED_HEADER, resolveProjectIdentity } from '../core/project-identity.js';
 //# sourceMappingURL=project-identity.js.map

package/dist/entry/session-text.d.ts

@@ -3,5 +3,5 @@ export { scrubForSharing } from '../capture/share-scrub.js';
 export { transcriptWorkingState, WORKING_STATE_CAPS } from '../capture/working-state.js';
 export { lessonFromFailure, failureReport, type FailureReport } from '../capture/failure-reading.js';
 export { collectHandoffEvidence } from '../capture/handoff-evidence.js';
-export { compactSummaryBody, parseCompactionItems, COMPACTION_ITEM_MAX_CHARS, COMPACTION_ITEM_ROW_CAP } from '../util/compaction-items.js';
+export { compactSummaryBody, parseCompactionItems, COMPACTION_ITEM_MAX_CHARS, COMPACTION_ITEM_ROW_CAP, } from '../util/compaction-items.js';
 //# sourceMappingURL=session-text.d.ts.map

package/dist/entry/session-text.js

@@ -5,5 +5,5 @@ export { scrubForSharing } from '../capture/share-scrub.js';
 export { transcriptWorkingState, WORKING_STATE_CAPS } from '../capture/working-state.js';
 export { lessonFromFailure, failureReport } from '../capture/failure-reading.js';
 export { collectHandoffEvidence } from '../capture/handoff-evidence.js';
-export { compactSummaryBody, parseCompactionItems, COMPACTION_ITEM_MAX_CHARS, COMPACTION_ITEM_ROW_CAP } from '../util/compaction-items.js';
+export { compactSummaryBody, parseCompactionItems, COMPACTION_ITEM_MAX_CHARS, COMPACTION_ITEM_ROW_CAP, } from '../util/compaction-items.js';
 //# sourceMappingURL=session-text.js.map

package/dist/entry/sqlite-handles.d.ts

@@ -0,0 +1,10 @@
+import { closeHippoDb as closeHandle, type DatabaseSyncLike as HandleType, openHippoDb as openHandle, openHippoDbReadOnly as openHandleReadOnly } from '../db/index.js';
+/** @deprecated The package root stops exporting this in 3.0. */
+export declare const openHippoDb: typeof openHandle;
+/** @deprecated The package root stops exporting this in 3.0. */
+export declare const openHippoDbReadOnly: typeof openHandleReadOnly;
+/** @deprecated The package root stops exporting this in 3.0. */
+export declare const closeHippoDb: typeof closeHandle;
+/** @deprecated The package root stops exporting this in 3.0. */
+export type DatabaseSyncLike = HandleType;
+//# sourceMappingURL=sqlite-handles.d.ts.map

package/dist/entry/sqlite-handles.js

@@ -0,0 +1,9 @@
+// The SQLite handle helpers the 2.x package root still exports; the root drops them in 3.0.
+import { closeHippoDb as closeHandle, openHippoDb as openHandle, openHippoDbReadOnly as openHandleReadOnly, } from '../db/index.js';
+/** @deprecated The package root stops exporting this in 3.0. */
+export const openHippoDb = openHandle;
+/** @deprecated The package root stops exporting this in 3.0. */
+export const openHippoDbReadOnly = openHandleReadOnly;
+/** @deprecated The package root stops exporting this in 3.0. */
+export const closeHippoDb = closeHandle;
+//# sourceMappingURL=sqlite-handles.js.map

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

@@ -1,13 +1,13 @@
-export { hasGroup, sqliteStore, type AmbientCandidateRequest, type ContextReads, type EntryRemoval, type EntryTarget, type EntryWrite, type EntryWrites, type HippoStore, type KeyAudit, type KeyListQuery, type KeyMint, type KeyRevoke, type KeyWrites, type LastRecall, type LastRecallWrites, type OutcomeWrite, type RawArchive, type RecallSearchArgs, type RecallWrites, type SelfKeyMint, type StoreGroup, type StoreGroups, type SupersedeWrite, type VectorReads, type VectorBackfillQuery, type VectorRowWrite, type VectorWrite, type VectorWriteResult, type VectorWrites, } from '../store/index.js';
+export { hasGroup, narrowStore, sqliteStore, type AmbientCandidateRequest, type CardCreate, type Cards, type Conflicts, type ContextReads, type Dormant, type DormantRestoreRequest, type EntryRemoval, type EntryTarget, type EntryWrite, type EntryWrites, type Goals, type HippoStore, type KeyAudit, type KeyListQuery, type KeyMint, type KeyRevoke, type KeyWrites, type LastRecall, type LastRecallWrites, type OutcomeWrite, type RawArchive, type RecallSearchArgs, type RecallWrites, type Reports, type SelfKeyMint, type Sessions, type StoreGroup, type StoreGroups, type StoreWith, type SupersedeWrite, type VectorReads, type VectorBackfillQuery, type VectorRowWrite, type VectorWrite, type VectorWriteResult, type VectorWrites, type WorkingMemoryFilter, type WorkingMemoryPush, } from '../store/index.js';
 export { entryAfterOutcome } from '../core/memory.js';
 export { rejectionDigest } from '../store/rejection.js';
 export { RejectedValueError } from '../core/api-errors.js';
 export { ownScopeTouches } from '../core/recall-scope.js';
-export type { HippoDbContext } from '../api/types.js';
+export type { ContextWith, HippoDbContext } from '../api/types.js';
 export type { ApiKeyListItem, ApiKeyListRow, ApiKeyRecord, ListApiKeysOpts, NewApiKey } from '../store/auth.js';
 export type { KeysetPosition } from '../util/keyset.js';
 export type { AppendAuditOpts, AuditEvent, ListAuditAfterOpts } from '../store/audit.js';
-export type { ContinuityBlock } from '../api/recall-types.js';
+export type { ContinuityBlock } from '../api/recall/types.js';
 export type { ActiveGoals, GetActiveGoalsOpts, Goal, GoalRecallLogRow, RetrievalPolicy } from '../store/goals.js';
 export type { MemoryEntry } from '../core/memory.js';
 export type { ClassResolution, PlanningFallacyEvidence } from '../store/planning-fallacy-evidence.js';
@@ -17,15 +17,28 @@ export type { StrengthenOptions } from '../store/entry-writes.js';
 export type { OriginFilter, RecallScopeFilter, VectorCandidateSpec } from '../store/search-rows.js';
 export type { ContinuityKey } from '../store/sessions.js';
 export type { SessionEvent, TaskSnapshot } from '../store/rows.js';
-export type { SessionHandoff } from '../core/handoff.js';
-export type { AmbientLoadResult, AmbientRecallRequest, ContextCandidateFilter, RecentOrigins } from '../store/candidates.js';
+export type { HandoffOutcome, SessionHandoff } from '../core/handoff.js';
+export type { Card, CardComment, CardRun, CardStatus } from '../core/card.js';
+export type { CardDetail } from '../store/card-detail.js';
+export type { CompleteGoalOpts, PushGoalOpts } from '../store/goals.js';
+export type { HandoffFilter, SessionEndHandoffRequest } from '../store/handoffs.js';
+export type { ResolveConflictOpts, ResolveConflictRequest } from '../store/conflicts.js';
+export type { DormantMemory, DormantRestoreOutcome, DormantSnapshot, ListDormantOpts } from '../store/dormant.js';
+export type { EntryCursor, EntryPage } from '../store/entry-reads.js';
+export type { FailureSummary } from '../store/failure-log.js';
+export type { MemoryConflict } from '../store/rows.js';
+export type { SessionEventInput, SnapshotInput } from '../store/sessions.js';
+export type { StrengthTallies } from '../store/candidates.js';
+export type { TokenSummary } from '../store/token-ledger.js';
+export type { WorkingMemoryItem } from '../store/working-memory.js';
+export type { AmbientLoadResult, AmbientRecallRequest, ContextCandidateFilter, RecentOrigins, } from '../store/candidates.js';
 export type { AmbientStoreFilter } from '../store/ambient.js';
 export type { AmbientTallies } from '../core/ambient.js';
 export type { TokenUse } from '../store/token-ledger.js';
 export type { EmbeddingIndexState } from '../store/vector-index.js';
 export type { PhysicsParticle } from '../core/physics.js';
 export { StoreBusyError } from '../store/port.js';
-export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows, type VectorMatch, type VectorRow } from '../db/vector-store.js';
+export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows, type VectorMatch, type VectorRow, } from '../db/vector-store.js';
 export { bufferToFloat32, float32ToBuffer } from '../util/vector-codec.js';
 export { replacesIndex } from '../store/vector-index.js';
 export { passesScopeFilterForRecall, RECALL_DEFAULT_DENY_SCOPES } from '../core/recall-scope.js';

package/dist/entry/store-kit.js

@@ -1,16 +1,18 @@
-// The hippo-memory/store-kit subpath: the contract for a second HippoStore (port types, row types, hippo.db's rule helpers),
+// The hippo-memory/store-kit subpath: the contract for a second HippoStore (port types, row types, hippo.db's rule
+// helpers),
 // so a store built on it applies hippo.db's rules with the same code.
 // An add-on serves from another database by passing serve() its own HippoStore.
-export { hasGroup, sqliteStore, } from '../store/index.js';
+export { hasGroup, narrowStore, sqliteStore, } from '../store/index.js';
 // An add-on store's entry writes apply an outcome, guard tombstones and check reach exactly as hippo.db does.
 export { entryAfterOutcome } from '../core/memory.js';
 export { rejectionDigest } from '../store/rejection.js';
 export { RejectedValueError } from '../core/api-errors.js';
 export { ownScopeTouches } from '../core/recall-scope.js';
 export { StoreBusyError } from '../store/port.js';
-// An add-on store encodes, decodes and ranks vectors and particles with hippo.db's own code, and drops the index by its rule,
+// An add-on store encodes, decodes and ranks vectors and particles with hippo.db's own code, and drops the index by its
+// rule,
 // so both stores keep the same bytes and return the same ids in the same order.
-export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows } from '../db/vector-store.js';
+export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows, } from '../db/vector-store.js';
 export { bufferToFloat32, float32ToBuffer } from '../util/vector-codec.js';
 export { replacesIndex } from '../store/vector-index.js';
 // An add-on's ContextReads applies hippo.db's scope, secret, tally and rarest-term rules with the same code.

package/dist/eval/eval-stats.d.ts

@@ -1,5 +1,9 @@
-/** Statistics and cost accounting for the token-efficiency evals: cost is priced over four buckets (uncached input, cache write, cache read, output).
- *  Uncertainty uses paired, cluster (same-repository tasks are not independent) and paired-ratio bootstraps; every resampler takes a seed. */
+/**
+ * Statistics and cost accounting for the token-efficiency evals: cost is priced over four buckets (uncached input,
+ * cache write, cache read, output).
+ * Uncertainty uses paired, cluster (same-repository tasks are not independent) and paired-ratio bootstraps; every
+ * resampler takes a seed.
+ */
 /** Token usage for one model call or one whole task, split by how it is billed. */
 export interface Usage {
     /** Input tokens billed at the base input price (not read from or written to a cache). */
@@ -11,7 +15,10 @@ export interface Usage {
     /** Output tokens, including any reasoning tokens the provider bills as output. */
     outputTokens: number;
 }
-/** Prices in dollars per million tokens, taken from the provider's current price page for the exact model; this module has no built-in prices. */
+/**
+ * Prices in dollars per million tokens, taken from the provider's current price page for the exact model; this module
+ * has no built-in prices.
+ */
 export interface Prices {
     inputPerMTok: number;
     cacheWritePerMTok: number;
@@ -22,8 +29,12 @@ export interface Prices {
 export declare function addUsage(...usages: Usage[]): Usage;
 /** Dollar cost of `usage` at `prices`. */
 export declare function priceUsage(usage: Usage, prices: Prices): number;
-/** Relative cache-bucket prices against the base input price, for cost in "uncached-equivalent tokens" when no dollar prices are given.
- *  Defaults follow Anthropic's ratios (5-minute cache write 1.25x, cache read 0.1x); pass another provider's ratios when needed. */
+/**
+ * Relative cache-bucket prices against the base input price, for cost in "uncached-equivalent tokens" when no dollar
+ * prices are given.
+ * Defaults follow Anthropic's ratios (5-minute cache write 1.25x, cache read 0.1x); pass another provider's ratios when
+ * needed.
+ */
 export interface CacheRatios {
     write: number;
     read: number;
@@ -52,9 +63,15 @@ export interface BootstrapOpts {
     /** PRNG seed. Default 1. */
     seed?: number;
 }
-/** Paired bootstrap for the mean of per-task differences (treatment minus control, same task); an interval excluding zero is the bar for a real difference. */
+/**
+ * Paired bootstrap for the mean of per-task differences (treatment minus control, same task); an interval excluding
+ * zero is the bar for a real difference.
+ */
 export declare function pairedBootstrap(diffs: number[], opts?: BootstrapOpts): Estimate;
-/** Cluster bootstrap for the mean of per-task differences: resamples whole clusters (e.g. one repository), because tasks in a cluster are not independent. */
+/**
+ * Cluster bootstrap for the mean of per-task differences: resamples whole clusters (e.g. one repository), because tasks
+ * in a cluster are not independent.
+ */
 export declare function clusteredPairedBootstrap(diffsByCluster: ReadonlyMap<string, number[]>, opts?: BootstrapOpts): Estimate;
 /** One task's outcome in one arm, for {@link costPerResolvedDelta}. */
 export interface ArmOutcome {
@@ -72,7 +89,9 @@ export interface CostPerResolvedDelta {
     /** (treatment minus control) / control, with its interval. Negative is a saving. */
     relative: Estimate;
 }
-/** Cost per resolved task in two arms on the same tasks, with a paired bootstrap (`control[i]` and `treatment[i]` must be the same task).
+/**
+ * Cost per resolved task in two arms on the same tasks, with a paired bootstrap (`control[i]` and `treatment[i]` must
+ * be the same task).
  *  Resamples in which an arm resolves nothing are dropped; `iterations` reports how many were kept. */
 export declare function costPerResolvedDelta(control: ArmOutcome[], treatment: ArmOutcome[], opts?: BootstrapOpts): CostPerResolvedDelta;
 /** pass@k: share of tasks with at least one success in their first k runs.