hippo-memory 1.72.0 → 2.1.0

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

@@ -0,0 +1,50 @@
+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 { 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 { 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';
+export type { PredictionBaserate } from '../store/predictions.js';
+export type { RecallTraceInput } from '../store/recall-trace.js';
+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 { 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 { 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';
+export { SECRET_TAGS } from '../util/secret-detect.js';
+export { tallyAmbientEntries } from '../core/ambient.js';
+export { ftsTermParts, rarestFtsQuery } from '../core/prompt-recall.js';
+export { OTHER_STORE_MARKER } from '../db/index.js';
+export { isSharedStore } from '../core/config.js';
+//# sourceMappingURL=store-kit.d.ts.map

package/dist/entry/store-kit.js

@@ -0,0 +1,27 @@
+// 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, 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,
+// 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 { 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.
+export { passesScopeFilterForRecall, RECALL_DEFAULT_DENY_SCOPES } from '../core/recall-scope.js';
+export { SECRET_TAGS } from '../util/secret-detect.js';
+export { tallyAmbientEntries } from '../core/ambient.js';
+export { ftsTermParts, rarestFtsQuery } from '../core/prompt-recall.js';
+// store copy --db writes the marker into the other store's folder.
+export { OTHER_STORE_MARKER } from '../db/index.js';
+// An add-on that serves a team store checks the flag before it starts.
+export { isSharedStore } from '../core/config.js';
+//# sourceMappingURL=store-kit.js.map

package/dist/entry/testing.d.ts

@@ -0,0 +1,6 @@
+export { _resetAblationCacheForTests } from '../core/ablation.js';
+export { _resetSharedStoreCacheForTests } from '../core/config.js';
+export { _resetLossAversionRatioCacheForTests } from '../core/memory.js';
+export { _resetSessionRecallHistoryMcpForTests } from '../mcp/session-state.js';
+export { __resetSessionRecallHistoryHttp } from '../server/routes/recall.js';
+//# sourceMappingURL=testing.d.ts.map

package/dist/entry/testing.js

@@ -0,0 +1,7 @@
+// Test seams for add-ons and hippo's own suite. Not for production code; no semver guarantee beyond the major version.
+export { _resetAblationCacheForTests } from '../core/ablation.js';
+export { _resetSharedStoreCacheForTests } from '../core/config.js';
+export { _resetLossAversionRatioCacheForTests } from '../core/memory.js';
+export { _resetSessionRecallHistoryMcpForTests } from '../mcp/session-state.js';
+export { __resetSessionRecallHistoryHttp } from '../server/routes/recall.js';
+//# sourceMappingURL=testing.js.map

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.

package/dist/eval/eval-stats.js

@@ -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.
+ */
 const DEFAULT_ITERATIONS = 5000;
 const DEFAULT_TWO_LEVEL_ITERATIONS = 10_000;
 const DEFAULT_ALPHA = 0.05;
@@ -48,7 +52,10 @@ function percentileInterval(samples, alpha) {
 function mean(xs) {
     return xs.length === 0 ? 0 : xs.reduce((s, x) => s + x, 0) / xs.length;
 }
-/** 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 function pairedBootstrap(diffs, opts = {}) {
     const iterations = opts.iterations ?? DEFAULT_ITERATIONS;
     const alpha = opts.alpha ?? DEFAULT_ALPHA;
@@ -65,7 +72,10 @@ export function pairedBootstrap(diffs, opts = {}) {
     }
     return { estimate: mean(diffs), ...percentileInterval(samples, alpha), iterations };
 }
-/** 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 function clusteredPairedBootstrap(diffsByCluster, opts = {}) {
     const iterations = opts.iterations ?? DEFAULT_ITERATIONS;
     const alpha = opts.alpha ?? DEFAULT_ALPHA;
@@ -94,7 +104,9 @@ function costPerResolved(outcomes) {
     const cost = outcomes.reduce((s, o) => s + o.cost, 0);
     return resolved === 0 ? Number.POSITIVE_INFINITY : cost / resolved;
 }
-/** 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 function costPerResolvedDelta(control, treatment, opts = {}) {
     if (control.length !== treatment.length) {

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

@@ -1,4 +1,6 @@
-/** Self-contained feature eval suite: a synthetic corpus with known ground truth, per-feature metrics and regression detection against a saved baseline.
+/**
+ * Self-contained feature eval suite: a synthetic corpus with known ground truth, per-feature metrics and regression
+ * detection against a saved baseline.
  *  Zero API calls (no LLM judge, no embeddings), deterministic (fixed timestamps, content, IDs) and fast. */
 import { type MemoryEntry } from '../core/memory.js';
 export type FeatureCategory = 'direct-recall' | 'extraction-preference' | 'dag-drilldown' | 'temporal' | 'noise-resistance' | 'multi-hop';