@avantf/dsh-mem 0.4.1 → 0.6.0

package/lib/engine/mem-contract/types.d.ts

@@ -23,7 +23,6 @@ export interface FactSummary {
     /** Remaining ACTIVE days before `forgot`; null when pinned / non-active / trust disabled. */
     remaining_days: number | null;
     helpful_count: number;
-    mirror_source: string | null;
     created_at: string;
     archived_at: string | null;
     archive_reason: string | null;
@@ -52,7 +51,6 @@ export declare const RETENTION_DIAGNOSTIC_FIELDS: readonly ["trust_score", "rema
 export declare function withoutRetentionDiagnostics<T>(value: T): T;
 export interface FactDetail extends FactSummary {
     retrieval_count: number;
-    mirror_target: string | null;
     supersedes_id: number | null;
     entities: string[];
     triples: FactTriple[];
@@ -68,6 +66,33 @@ export interface FactDetail extends FactSummary {
     /** Effective reinforcement events in the current 24h window (recall + feedback). */
     bonus_count: number;
     bonus_window_at: string | null;
+    /**
+     * P-08: where this fact came from, as recorded rows. Empty when the writer gave no `source_ref`
+     * — the read surface must show "unknown" rather than invent one.
+     */
+    sources: FactSourceView[];
+    /**
+     * P-07: when the fact became true / stopped being true. `null` = unknown; `valid_to` set while
+     * the row is still `active` means "still valid, known to end at T" (the state
+     * `mem_remember valid_until` creates), while an archived row's `valid_to` is an audit stamp.
+     */
+    valid_from: string | null;
+    valid_to: string | null;
+    /**
+     * P-07: the fact that supersedes this one, DERIVED from the existing `supersedes_id` link
+     * (reverse lookup) — no redundant column. `null` when nothing supersedes it.
+     */
+    superseded_by: number | null;
+    /**
+     * P-10: how many times this exact content has been asserted. `1` for every row that predates the
+     * counter and for a first write; a verbatim duplicate `add` moves it. Never scored.
+     */
+    assert_count: number;
+}
+/** P-08: one provenance row on a fact (`fact_sources`), as `admin detail` renders it. */
+export interface FactSourceView {
+    kind: 'session' | 'kb_doc' | 'tool' | 'manual';
+    ref: string;
 }
 /** A single hit from hybrid retrieval over the merged candidate pool. */
 export interface RecallHit {
@@ -107,6 +132,38 @@ export interface RecallHit {
      * `source_ref`, so the caller knows it exists and can fetch it explicitly.
      */
     truncated?: boolean;
+    /**
+     * P-01 per-leg evidence, present only when the caller asked (`include_scores`) — absent is the
+     * default and is what keeps the envelope byte-identical for every existing caller.
+     *
+     * Keys are the LEG NAMES actually fused for this hit's store (`semantic` / `fts` / `jaccard` /
+     * `hrr`; the HRR probe shares the jaccard weight, which is why it is named separately). A leg
+     * that did not recall this candidate is `null` — an explicit "this leg has nothing to say",
+     * which is information a missing key would lose.
+     */
+    scores?: Record<string, RecallLegScore | null>;
+    /**
+     * P-01: the FUSION output score for this hit, before any cross-store normalization.
+     *
+     * `score` is what the surface ranks by and can be re-scaled downstream (`crossQuery` min-max
+     * normalizes over the merged pool), so a caller reasoning about "which leg carried this" needs
+     * the fusion value itself rather than a number that means a different thing per surface.
+     */
+    final?: number;
+    /**
+     * P-07/P-13: the fact's event time / known end, serialized ONLY when non-null (the same
+     * convention as {@link RecallHit.truncated}). `null` means "unknown", and omitting the key keeps
+     * every pre-P-07 envelope byte-identical. Both are display/audit only — no leg filters on them.
+     */
+    valid_from?: string;
+    valid_to?: string;
+}
+/** P-01: one leg's contribution to a hit (see {@link RecallHit.scores}). */
+export interface RecallLegScore {
+    /** The leg's own raw score, on its own scale. */
+    raw: number;
+    /** `raw / legMax` in `[0,1]` — the value fusion actually weighted. Not comparable across legs. */
+    normalized: number;
 }
 /**
  * The relevance floors in force for ONE retrieval (`0` = that leg is not gated).
@@ -121,7 +178,7 @@ export interface RetrievalFloors {
     semantic: number;
     /** Distinct-query-term floor for the FTS leg (`retriever.min_fts_terms`; 1 when degraded). */
     fts: number;
-    /** Entity-overlap ratio floor (`retriever.min_jaccard`). */
+    /** Anchored query-coverage floor for the entity leg (`retriever.min_jaccard`, see `store/entity_leg.ts`). */
     jaccard: number;
 }
 /**
@@ -235,6 +292,12 @@ export interface RememberResult {
     is_new: boolean;
     revived: boolean;
     entities: string[];
+    /**
+     * P-10: how many times this content has been asserted. A first write is `1`; a verbatim
+     * duplicate `add` increments it. Reviving an archived row does NOT increment it — that is a
+     * resurrection, not a new assertion.
+     */
+    assert_count: number;
     /**
      * Contradictions detected against the existing corpus while writing this fact (DESIGN §11).
      * Present only when at least one was found, so the writer learns immediately instead of
@@ -258,11 +321,8 @@ export interface RetrievalHealth {
     /** Queries where the semantic leg was live / degraded (FTS+entity only). */
     semantic_live: number;
     semantic_degraded: number;
-    rerank_used: number;
-    rerank_fallback: number;
     /** Model-facing text that had to be bounded by a budget (see `retrieval-core/text_budget`). */
     embedding_truncated: number;
-    rerank_truncated: number;
     output_truncated: number;
     /**
      * Retrieval legs that returned exactly their cap, i.e. whose tail was dropped (`retriever.leg_cap`).
@@ -287,10 +347,7 @@ export interface RetrievalHealthSummary {
     avg_latency_ms: number;
     max_latency_ms: number;
     semantic_live_rate: number;
-    rerank_used: number;
-    rerank_fallback: number;
     embedding_truncated: number;
-    rerank_truncated: number;
     output_truncated: number;
     /** Retrieval legs that returned exactly their cap (see `RetrievalHealth`). */
     legs_capped: number;
@@ -299,11 +356,77 @@ export interface RetrievalHealthSummary {
     updated_at: string | null;
     by_kind: Record<string, KindHealth>;
 }
+/**
+ * Persisted-vector health of the ACTIVE corpus, relative to the vector space the store writes into
+ * NOW — the DETECTION half of "changing the embedding space is a data migration" (DESIGN §20).
+ *
+ * Deliberately cheap: it compares the recorded width and space id only, never decoding the blobs, so
+ * the `/mem` status surface can read it on every poll without loading a whole corpus.
+ */
+export interface VectorSpaceHealth {
+    /** Active facts whose persisted vector has a different width than `semantic.dim`. */
+    stale: number;
+    /** Active facts whose persisted vector is provably from another model space (same width). */
+    space_stale: number;
+}
+/**
+ * SQLite WAL sidecar health for the memory database (P-06).
+ *
+ * The `-wal` / `-shm` files are TRANSIENT: versioning or copying them next to `memory.db` can leave
+ * a database that will not recover. `admin stats` is offline and dependency-free by design, so it
+ * never shells out to git to ask whether they are tracked — it only reports the one fact a single
+ * `statSync` can establish. The "do not version these; `wal_checkpoint(TRUNCATE)` before a commit or
+ * a copy" rule lives in `docs/INSTALL.md`.
+ */
+export interface WalHealth {
+    /** The `-wal` sidecar exists right now (a checkpoint has not removed it, or the store is live). */
+    present: boolean;
+    /** Size of `-wal` in bytes; 0 when it does not exist or has been truncated. */
+    bytes: number;
+    /**
+     * The operator-facing reminder, non-null only while `-wal` actually holds bytes. An EMPTY
+     * sidecar (the normal post-`wal_checkpoint(TRUNCATE)` state) and an absent one are both silent —
+     * this is a backup-discipline hint, never an error.
+     */
+    warning: string | null;
+}
 /** `mem_admin stats`: store counts plus the retrieval-health counters. */
 export interface StatsSummary {
     active: number;
     archived: number;
     retrieval: RetrievalHealthSummary;
+    /**
+     * Vector-space health, so "retrieval silently degraded after a model upgrade" is visible from the
+     * status surface instead of only from a one-shot startup warning.
+     */
+    vectors: VectorSpaceHealth;
+    /**
+     * WAL sidecar health, so "there is an uncheckpointed `-wal` next to the database" is visible
+     * before someone versions or copies the data root.
+     */
+    wal: WalHealth;
+    /**
+     * P-08 source coverage. Reported from day one so the field cannot silently become empty: a
+     * `source_ref` that never lands (or a predicate that stops matching) shows up here as `0`.
+     */
+    sources: SourceCoverage;
+    /** P-13 `valid_from` coverage, the same "prevent an empty field" argument as {@link StatsSummary.sources}. */
+    validity: ValidityCoverage;
+}
+/** P-08: how much of the ACTIVE corpus carries provenance (`fact_sources`). */
+export interface SourceCoverage {
+    active: number;
+    /** ACTIVE facts with at least one `fact_sources` row (a fact with three sources counts once). */
+    facts_with_source: number;
+    /** `facts_with_source / active`, `0` on an empty corpus. */
+    coverage: number;
+}
+/** P-13: how much of the ACTIVE corpus carries an event time (`valid_from`). */
+export interface ValidityCoverage {
+    active: number;
+    facts_with_valid_from: number;
+    /** `facts_with_valid_from / active`, `0` on an empty corpus. */
+    coverage: number;
 }
 /** One page of facts (`mem_admin list`). */
 export interface FactPage {
@@ -347,10 +470,42 @@ export interface VectorsDiagnostic {
     space_stale: number;
     indexed: number;
     unindexed: number;
+    /**
+     * Distinct recorded spaces across the WHOLE table (archived rows included), while `stale` /
+     * `space_stale` count only ACTIVE rows — an archived row legitimately keeps its old vector, so the
+     * two must not be compared directly.
+     */
     models: Record<string, number>;
     /** Which backend is actually serving reads (`auto:local_numpy` → `auto:hnswlib`). */
     store: string;
 }
+/**
+ * One BOUNDED slice of the vector-space migration (`MemoryStore.migrateVectorsBatch`).
+ *
+ * The migration is what turns "the default embedder changed" from a silent degradation into a
+ * resumable background repair: each call re-encodes at most `batchSize` rows, and the remaining
+ * count is what the next call (or the next process, after a restart) resumes from.
+ */
+export interface VectorMigrationProgress {
+    /** Active rows still not usable by the semantic leg after this slice (old width/space, or no vector). */
+    remaining: number;
+    /** Rows re-encoded into the current space by this slice. */
+    migrated: number;
+    /** Rows whose old-space bytes were dropped so a re-encode could replace them. */
+    dropped: number;
+    /** Usable persisted vectors re-added to the live index (no model needed). */
+    reindexed: number;
+    /** `false` when the model was not loaded: nothing could be encoded this slice. */
+    semantic_available: boolean;
+}
+/**
+ * The outcome of a whole migration drive (`MemoryStore.migrateVectors`): the last slice plus
+ * cumulative counters, and whether the `semantic.auto_migrate` switch allowed any work at all.
+ */
+export interface VectorMigrationOutcome extends VectorMigrationProgress {
+    /** `false` when `semantic.auto_migrate` is off — nothing was migrated on purpose. */
+    enabled: boolean;
+}
 /**
  * `mem_admin vectors_fix`: what a repair did, or — with `dry_run` — what it WOULD do.
  *

package/lib/engine/mem-retrieval/adapters/local_bge.d.ts

@@ -1,4 +1,4 @@
-import type { SemanticBackend } from '../interfaces.js';
+import type { SemanticBackend, SemanticRepresentation } from '../interfaces.js';
 /**
  * The injected pipeline surface: one text OR an array of texts in, a tensor out.
  *
@@ -31,6 +31,18 @@ export interface ModelEnv {
      * text first and logs it once (`text_budget.ts`).
      */
     maxInputTokens?: number;
+    /**
+     * Pooling strategy handed to the feature-extraction pipeline (`mean` by default). Part of the
+     * representation fingerprint (`representationKey`): `mean` and `cls` produce DIFFERENT
+     * coordinates from the same weights, so a change here is a data migration, not a tuning knob.
+     */
+    pooling?: string;
+    /**
+     * Whether the pipeline L2-normalizes (`true` by default). Also part of the representation:
+     * an un-normalized vector ranks differently under cosine, so switching it invalidates every
+     * persisted vector exactly like a model swap does.
+     */
+    normalize?: boolean;
     /**
      * Do NOT warm in the constructor: the first `encode()` / `encodeBatch()` warms lazily.
      *
@@ -61,13 +73,34 @@ export declare class LocalBgeBackend implements SemanticBackend {
     private _dimWarned;
     private _lengthWarned;
     private _window;
+    /** Cached so the fingerprint cannot move while the process runs (see {@link representation}). */
+    private _representation;
     private readonly configuredMax;
+    private readonly pooling;
+    private readonly normalize;
     private readonly model;
     private readonly env;
     private readonly pipeFactory;
     private readonly gate;
     constructor(model: string, dim: number, env?: Partial<ModelEnv>, pipeFactory?: PipeFactory);
     isAvailable(): boolean;
+    /**
+     * The representation knobs this adapter applies, resolved ONCE per instance.
+     *
+     * Resolved once on purpose: the model revision comes from disk, and a fingerprint that changed
+     * mid-process (install settles, sidecar appears) would make the store declare the rows it just
+     * wrote stale. The cost of reading it early is bounded and honest — a process that starts BEFORE
+     * the family provisioner lands the model writes a revision-less fingerprint for that session, and
+     * the next start re-encodes once into the revision-carrying one. The alternative (reading late)
+     * would re-encode on every restart instead.
+     *
+     * A missing sidecar is reported once, as a DEGRADATION: the fingerprint then cannot see a repo
+     * whose weights were re-pushed under the same name, which is a real (narrow) blind spot and must
+     * not be mistaken for a healthy state. It never throws, and it stays quiet while the weights are
+     * not on disk yet (a fresh install in flight has nothing to fingerprint; the sidecar arrives with
+     * the weights). The resolved representation is CACHED, so the warning is one line per process.
+     */
+    representation(): SemanticRepresentation;
     /**
      * Fire-and-forget retry for call sites that only observe availability. No-op
      * while the model is ready or an attempt is already in flight; otherwise
@@ -111,11 +144,8 @@ export declare class LocalBgeBackend implements SemanticBackend {
 /**
  * Apply this project's cache/mirror policy to transformers.js.
  *
- * `mod.env` is PROCESS-GLOBAL and last-writer-wins: the embedder and the reranker are two adapters
- * over ONE module, so whichever warms second decides what both see. Setting the keys from a single
- * place is what keeps the two from disagreeing — the reranker used to set `allowLocalModels` on its
- * own, which reads as a policy difference between the adapters and was really an accident of which
- * file got edited last. `allowLocalModels` is already the library default; it is stated here so the
- * policy is explicit rather than inherited, and identical for both adapters.
+ * `mod.env` is PROCESS-GLOBAL and last-writer-wins. Setting the keys from a single place is what
+ * keeps every future adapter over this module from disagreeing: `allowLocalModels` is already the
+ * library default, stated here so the policy is explicit rather than inherited.
  */
 export declare function applyModelEnv(mod: TransformersModule, env: ModelEnv): void;

package/lib/engine/mem-retrieval/fusion.d.ts

@@ -29,6 +29,17 @@ export interface FusionPath {
 export interface Hit {
     id: number;
     score: number;
+    /**
+     * P-01 per-leg evidence, aligned to the `paths` array the caller passed, and only present when
+     * the caller asked for it (`opts.includeLegs`). `null` at an index means that leg did not
+     * recall this candidate — the explicit "no evidence", which a missing entry would hide.
+     */
+    legs?: (LegScore | null)[];
+}
+/** P-01: one leg's contribution to one candidate (raw on the leg's scale + the value fused). */
+export interface LegScore {
+    raw: number;
+    normalized: number;
 }
 /**
  * Scale raw scores by the set's maximum, into [0,1].
@@ -50,4 +61,6 @@ export declare function scaleByMax(scores: Map<number, number>): Map<number, num
  * scaled scores collide far more often than min-max ones did (both legs of a pair can rank two
  * candidates identically), and the previous order was Map-insertion order.
  */
-export declare function fuse(paths: FusionPath[], topK: number): Hit[];
+export declare function fuse(paths: FusionPath[], topK: number, opts?: {
+    includeLegs?: boolean;
+}): Hit[];

package/lib/engine/mem-retrieval/index.d.ts

@@ -1,14 +1,12 @@
 export * from './interfaces.js';
+export * from './representation.js';
 export * from './log.js';
 export * from './stats.js';
 export * from './text_budget.js';
 export * from './budget.js';
 export * from './registry.js';
 export * from './fusion.js';
-export * from './rerank.js';
 export * from './adapters/local_numpy.js';
 export * from './adapters/hnswlib.js';
 export * from './adapters/auto_vstore.js';
-export * from './adapters/none_reranker.js';
 export * from './adapters/local_bge.js';
-export * from './adapters/local_reranker.js';

package/lib/engine/mem-retrieval/interfaces.d.ts

@@ -1,8 +1,38 @@
 /**
- * The three stable contracts the business flow depends on.
+ * The two stable contracts the business flow depends on.
  * The business flow (fusion pipeline, stores, tools, router, UI) must depend only on
  * these interfaces — never on a concrete backend. See DESIGN §5.
  */
+/**
+ * HOW a backend turns text into a vector — the knobs that decide which coordinates a stored vector
+ * lives in, beyond `name`/`dim`.
+ *
+ * The vector-space identity used to record only `backend/model/dim`, so a change of pooling,
+ * normalization, input window or the weights behind the same repo name produced the SAME identity:
+ * new vectors were written into an index that still held the old ones and nothing detected the
+ * migration (see `db/vectors.ts` and DESIGN §20). A backend that can name these knobs declares them
+ * here and the space id carries them (see `representationKey`).
+ */
+export interface SemanticRepresentation {
+    /** Pooling strategy handed to the feature-extraction pipeline (`mean`, `cls`, …). */
+    readonly pooling: string;
+    /** Whether vectors are L2-normalized by the pipeline (cosine relies on it). */
+    readonly normalize: boolean;
+    /**
+     * The CONFIGURED input-token cap (`0` = auto/declared window), i.e. the truncation window the
+     * adapter bounds text to before encoding. The CONFIGURED value, not the resolved one: the
+     * resolved window depends on the loaded tokenizer, so it is unknown before warmup — and the
+     * fingerprint must be identical before and after warmup, or a store would declare its own rows
+     * stale the moment the model finished loading.
+     */
+    readonly maxInputTokens: number;
+    /**
+     * Content identity of the model files (the family sidecar's revision sha), when one could be
+     * read. Absent = "could not be read" (not "known to be empty"): the fingerprint then omits it,
+     * which is the documented degradation, never an error.
+     */
+    readonly revision?: string;
+}
 /** Encodes text into a normalized embedding vector. */
 export interface SemanticBackend {
     readonly name: string;
@@ -10,6 +40,13 @@ export interface SemanticBackend {
     encode(text: string): Promise<Float32Array>;
     encodeBatch(texts: string[]): Promise<Float32Array[]>;
     isAvailable(): boolean;
+    /**
+     * Optional declaration of the representation knobs this backend applies. The built-in
+     * `local_bge` declares them; a third-party backend that omits this is fingerprinted as
+     * `rep=undeclared` (the space id still changes with name/dim), which is honest rather than a
+     * silent claim to a representation nobody verified.
+     */
+    representation?(): SemanticRepresentation;
     /** Optional async bootstrap: configure env + download/load the model. */
     warmUp?(): Promise<void>;
     /**
@@ -20,19 +57,6 @@ export interface SemanticBackend {
      */
     ensureWarm?(): void;
 }
-/** Re-ranks candidate facts/chunks by query relevance. */
-export interface Reranker {
-    readonly name: string;
-    rerank(query: string, candidates: {
-        id: number;
-        text: string;
-    }[]): Promise<number[]>;
-    isAvailable(): boolean;
-    /** Optional async bootstrap: configure env + download/load the model. */
-    warmUp?(): Promise<void>;
-    /** Optional non-blocking retry — see {@link SemanticBackend.ensureWarm}. */
-    ensureWarm?(): void;
-}
 /** Distance/ann index over entry vectors (per-store instance). */
 export interface VectorStore {
     readonly name: string;

package/lib/engine/mem-retrieval/registry.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from '../mem-contract/index.js';
-import type { Reranker, SemanticBackend, VectorStore } from './interfaces.js';
+import type { SemanticBackend, VectorStore } from './interfaces.js';
 type Factory<T> = (cfg: Config, opts?: ResolveOptions) => T;
 /**
  * How a backend is resolved.
@@ -8,16 +8,14 @@ type Factory<T> = (cfg: Config, opts?: ResolveOptions) => T;
  * family framework installs the model into the managed root ASYNCHRONOUSLY, so a constructor-time
  * warm would race that install and fetch a second copy. The plugin passes `deferWarm: true` and
  * warms from the model item's `onSettled`; every other caller (CLI, MCP, tests) keeps the eager
- * constructor warm. `encode()` / `rerank()` still warm lazily, so deferring never loses the model.
+ * constructor warm. `encode()` still warms lazily, so deferring never loses the model.
  */
 export interface ResolveOptions {
     /** Skip the constructor warm; the caller warms explicitly (see `ModelEnv.deferWarm`). */
     readonly deferWarm?: boolean;
 }
 export declare function registerSemanticBackend(name: string, factory: Factory<SemanticBackend>): void;
-export declare function registerReranker(name: string, factory: Factory<Reranker>): void;
 export declare function registerVectorStore(name: string, factory: Factory<VectorStore>): void;
 export declare function resolveSemantic(cfg: Config, opts?: ResolveOptions): SemanticBackend;
-export declare function resolveReranker(cfg: Config, opts?: ResolveOptions): Reranker;
 export declare function resolveVStore(cfg: Config): VectorStore;
 export {};

package/lib/engine/mem-retrieval/representation.d.ts

@@ -0,0 +1,50 @@
+import type { SemanticBackend, SemanticRepresentation } from './interfaces.js';
+/** The declared representation of a backend that does not implement `representation()`. */
+export declare const UNDECLARED_REPRESENTATION = "rep=undeclared";
+/** What {@link readModelRevision} found (or why it found nothing). */
+export interface ModelRevisionRead {
+    /** The model's content identity when the sidecar recorded one. */
+    readonly revision?: string;
+    /** Where it was looked for (the degradation warning names it). */
+    readonly path: string;
+    /** Why the revision is absent — short, for the one-line degradation warning. */
+    readonly detail: string;
+}
+/**
+ * Normalized, stable representation key embedded in a vector-space id.
+ *
+ * Field order is fixed and each value is normalized (lowercased pooling, 1/0 normalize, a
+ * truncated non-negative integer window), so two runs that describe the SAME representation always
+ * produce the SAME key — a fingerprint that changed spuriously would re-encode a whole corpus for
+ * nothing. A blank/absent revision is OMITTED rather than encoded as a placeholder: "unknown" then
+ * looks different from any known revision, which is the honest reading (the weights could have
+ * changed without this process being able to tell).
+ */
+export declare function representationKey(rep: SemanticRepresentation): string;
+/** {@link representationKey} for a live backend, or the explicit "undeclared" marker. */
+export declare function representationKeyOf(backend: SemanticBackend): string;
+/** The sidecar path for `model` under `cacheDir`, mirroring the base's flat-layout naming
+ * (`models--<owner>--<name>`), which is why a slash in the repo id becomes `--`.
+ */
+export declare function modelRecordPath(cacheDir: string, model: string): string;
+/**
+ * Whether the model's weights are actually on disk in the flat layout the adapter reads
+ * (`<cacheDir>/<repo>/config.json`).
+ *
+ * Only used to decide whether a missing revision is worth a WARNING: a machine that has never
+ * installed the model (a fresh install still in flight) has nothing to fingerprint yet, so the
+ * degradation is real but not yet reportable — warning there would be noise on every first run.
+ * Once the weights are present and the sidecar still is not, "no revision" is a genuine blind spot.
+ */
+export declare function modelFilesPresent(cacheDir: string, model: string): boolean;
+/**
+ * Read the family sidecar's revision for `model`, never throwing.
+ *
+ * Absence is a legitimate state (a model fetched by transformers.js directly, a machine that never
+ * ran the family provisioner, an install still in flight), not an error: the caller reports the
+ * degradation once and the fingerprint simply omits the revision.
+ *
+ * @param cacheDir - the model cache root the adapter actually reads (`semantic.cache_dir`).
+ * @param model - the repo id (`Xenova/bge-base-zh-v1.5`).
+ */
+export declare function readModelRevision(cacheDir: string, model: string): ModelRevisionRead;

package/lib/engine/mem-retrieval/stats.d.ts

@@ -21,8 +21,6 @@ export interface RetrievalEvent {
     results: number;
     latencyMs: number;
     semanticLive: boolean;
-    rerankUsed?: boolean;
-    rerankFallback?: boolean;
     /**
      * Per-leg candidates removed by the relevance floors before fusion. The per-leg shape is what
      * makes an empty result readable ("the FTS floor cut 7 rows" vs "no leg had a candidate"); the
@@ -32,7 +30,7 @@ export interface RetrievalEvent {
 }
 /** Record one completed retrieval. */
 export declare function recordRetrieval(event: RetrievalEvent): void;
-export type TruncationKind = 'embedding' | 'rerank' | 'output';
+export type TruncationKind = 'embedding' | 'output';
 /**
  * Record that a retrieval LEG returned exactly its cap, i.e. that its tail was dropped.
  *