@wrongstack/vector-memory 0.308.0 → 0.308.2

package/dist/sage-event-mirror.d.ts

@@ -0,0 +1,47 @@
+import type { MemoryPort } from '@wrongstack/core/types';
+import type { VectorMemoryStore } from './store.js';
+export interface VectorMemoryMirrorOptions {
+    store: VectorMemoryStore;
+    memoryStore: MemoryPort;
+    logger?: {
+        debug?(msg: string, ctx?: unknown): void | undefined;
+        warn?(msg: string, ctx?: unknown): void | undefined;
+    } | undefined;
+    /**
+     * Disable the listener (e.g. in tests where the bus is shared across
+     * suites). Returns a no-op disposer.
+     */
+    enabled?: boolean | undefined;
+}
+export interface VectorMemoryMirrorHandle {
+    /** Idempotent — calling twice is a no-op. */
+    dispose: () => void;
+}
+/**
+ * Subscribe the vector store to the SAGE event bus so live writes are
+ * mirrored. Returns a handle whose `dispose()` removes all listeners.
+ *
+ * Idempotency:
+ *  - `remember()` content-hash dedupes, so a re-fire of `memory.accepted`
+ *    with identical text is a no-op.
+ *  - The mirror skips session-scoped memories (privacy parity with
+ *    `createSageSurfaceSyncSource`).
+ *  - Errors are logged and swallowed; the SAGE write path is never blocked.
+ */
+export declare function subscribeVectorMemoryToSage(opts: VectorMemoryMirrorOptions): VectorMemoryMirrorHandle;
+/**
+ * Garbage-collect vector entries whose underlying SAGE memory is gone.
+ * Walks the store, looks up each `metadata.sageId` in the SAGE surface,
+ * and forgets entries whose SAGE id no longer resolves.
+ *
+ * Useful after bulk operations (`memory.cleared`, `hygiene.purge_deleted`)
+ * that emit a single top-level event but may not emit per-memory
+ * `memory.deleted` events.
+ */
+export declare function forgetStaleSageMirrors(store: VectorMemoryStore, memoryStore: MemoryPort, logger?: {
+    warn?(msg: string, ctx?: unknown): void | undefined;
+}): Promise<{
+    scanned: number;
+    removed: number;
+}>;
+//# sourceMappingURL=sage-event-mirror.d.ts.map

package/dist/sage-fusion.d.ts

@@ -0,0 +1,87 @@
+/**
+ * SAGE ⇄ Vector Memory fusion — combine a SAGE lexical candidate set with
+ * a parallel semantic recall from the vector store. Operates without
+ * modifying the SAGE store; the caller supplies both inputs and gets back
+ * a ranked, deduplicated list keyed by the SAGE memory id.
+ *
+ * The fusion is a Reciprocal Rank Fusion (RRF)-style blend rather than a
+ * raw cosine-blend, so it stays robust when one side returns nothing
+ * (e.g. embedding provider unavailable). All inputs are optional:
+ *   - `lexical` may be `[]` → fusion falls back to pure vector ranking.
+ *   - `vector` may be `[]` → fusion falls back to pure lexical ranking.
+ *   - either may be `undefined` → fusion silently drops that channel.
+ *
+ * The vector store is queried separately via `vectorStore.search(query)`,
+ * so callers that have already done so can pass the hits directly. When
+ * `vectorHits` is omitted, the function queries the store itself.
+ */
+import type { Sage, VectorRecallProvider } from '@wrongstack/sage';
+import type { VectorMemoryStore } from './store.js';
+import type { VectorSearchHit } from './types.js';
+export interface SageFusionOptions {
+    /** Vector store queried for additional semantic recall. Optional. */
+    store?: VectorMemoryStore | undefined;
+    /** Pre-computed vector hits. Skip the embedded `store.search()` call. */
+    vectorHits?: readonly VectorSearchHit[] | undefined;
+    /**
+     * Weight of the vector channel in the final score. 0 = pure lexical
+     * order, 1 = pure vector order. Default 0.3.
+     */
+    vectorWeight?: number | undefined;
+    /**
+     * Reciprocal-Rank-Fusion k constant. Lower values amplify the top hits
+     * of each channel; higher values flatten the curve. Default 60.
+     */
+    rrfK?: number | undefined;
+    /** Cosine threshold forwarded to `store.search()` when querying internally. */
+    threshold?: number | undefined;
+    /** Hard cap on the final fused result list. */
+    limit?: number | undefined;
+    /**
+     * Cosine threshold below which a vector-only hit is dropped (no lexical
+     * counterpart to lift it). Default 0 — keep all, let RRF decide.
+     */
+    vectorOnlyThreshold?: number | undefined;
+}
+export interface SageFusionHit {
+    memory: Sage;
+    /** 0..1, 0 if the candidate only appeared in the lexical channel. */
+    vectorScore: number | null;
+    /** 0..1, 0 if the candidate only appeared in the vector channel. */
+    lexicalScore: number | null;
+    /** 0..1, monotonically higher = better. */
+    finalScore: number;
+    /** Where the candidate came from. */
+    source: 'lexical' | 'vector' | 'both';
+}
+declare function lexicalRankScore(index: number, total: number): number;
+declare function vectorRankScore(index: number, total: number): number;
+/**
+ * Fuse lexical and vector recall into a single ranked list. The vector
+ * channel pulls additional memories the lexical index missed (semantic
+ * recall), and the lexical channel pulls precise matches the embedding
+ * model would under-rank (rare-token recall).
+ *
+ * Returned order is `finalScore` descending, capped at `limit`.
+ */
+export declare function fuseWithVectorMemory(query: string, lexical: readonly Sage[], options?: SageFusionOptions): Promise<SageFusionHit[]>;
+/**
+ * Wrap a `VectorMemoryStore` as a `VectorRecallProvider` so it can be
+ * passed to `searchSage({ vectorRecall })` and friends. The adapter is
+ * intentionally thin: it forwards `search` to `store.search()` and
+ * flattens the result into the structural shape the sage retrieval
+ * module expects.
+ *
+ * Caller responsibility: ensure the vector store has been warm-started
+ * via `startFirstBootSageSync()` (or equivalent) so vector hits carry
+ * `metadata.sageId` and can be fused with the lexical list.
+ */
+export declare function asVectorRecallProvider(store: VectorMemoryStore): VectorRecallProvider;
+declare function clamp01(value: number): number;
+export declare const __testing: {
+    lexicalRankScore: typeof lexicalRankScore;
+    vectorRankScore: typeof vectorRankScore;
+    clamp01: typeof clamp01;
+};
+export {};
+//# sourceMappingURL=sage-fusion.d.ts.map

package/dist/sage-port-wrapper.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Wrap an existing SAGE `MemoryPort` so that every `searchSage` /
+ * `unifiedSearch` / `retrieveForAudience` call automatically injects
+ * the supplied `VectorRecallProvider`. The wrapper preserves the
+ * underlying port's identity for callers that compare ports, but routes
+ * the read-side capability methods through a vector-augmented
+ * `searchSage`.
+ *
+ * Why a wrapper and not a direct constructor change:
+ *   - non-invasive: no migration needed for existing host construction
+ *   - opt-in: hosts that don't want vector augmentation just don't wrap
+ *   - testable: easy to mock the wrapper in unit tests
+ *
+ * The wrapper only augments paths that go through the read-side
+ * capability (`getCapability(SAGE_RETRIEVAL_CAPABILITY)` /
+ * `getCapability(SAGE_SURFACE_CAPABILITY)`). Other capabilities
+ * (write-side, hygiene, audit) pass through unchanged so the wrapper
+ * never widens the trust boundary.
+ */
+import type { MemoryPort } from '@wrongstack/core/types';
+import { type VectorRecallProvider } from '@wrongstack/sage';
+import type { VectorMemoryStore } from './store.js';
+export interface VectorPortWrappingOptions {
+    /** Vector store. The wrapper adapts it to the SAGE recall contract. */
+    store: VectorMemoryStore;
+    /**
+     * Optional pre-built provider. When omitted, the wrapper builds one via
+     * `asVectorRecallProvider(store)`.
+     */
+    vectorRecall?: VectorRecallProvider | undefined;
+    /**
+     * Cosine threshold forwarded to the vector backend. 0 = no threshold
+     * (keep all hits, let RRF decide).
+     */
+    threshold?: number | undefined;
+    /**
+     * Weight of the vector channel in the RRF blend. Default 0.3.
+     */
+    weight?: number | undefined;
+}
+/**
+ * Adapt a `VectorMemoryStore` to the SAGE `VectorRecallProvider` contract.
+ * Exported so the wrapper can be used directly by hosts that want a
+ * custom provider without wrapping the whole port.
+ */
+export declare function asVectorRecallProviderAdapter(store: VectorMemoryStore): VectorRecallProvider;
+/**
+ * Return a new `MemoryPort` that routes `searchSage` calls through the
+ * supplied `VectorRecallProvider`. All other capabilities are passed
+ * through unchanged.
+ */
+export declare function wrapMemoryPortWithVectorRecall(port: MemoryPort, options: VectorPortWrappingOptions): MemoryPort;
+//# sourceMappingURL=sage-port-wrapper.d.ts.map

package/dist/sage-sync-source.d.ts

@@ -0,0 +1,39 @@
+/**
+ * SageSyncSource adapter over a SAGE `SageSurface`.
+ *
+ * Cursor-walks `listSagePage({ statuses: ['active'] })` so the whole active
+ * corpus can be mirrored into the vector store via `syncFromSage()` without
+ * the caller hand-rolling pagination. The walk terminates naturally when
+ * `nextCursor` is empty (the canonical "end of corpus" signal) — the
+ * historical 5 000 hard cap was removed because it silently truncated
+ * large projects, and `nextCursor` already bounds the iteration.
+ *
+ * A `maxTotal` cap remains available for tests and pathological cases
+ * (e.g. a runaway enumerator that never reports `nextCursor: null`); the
+ * default is to walk the whole corpus.
+ *
+ * Privacy note: `sessionId`/`includeAllSessions` are deliberately NOT set.
+ * Every SAGE retrieval surface hides owned session-scoped memories from an
+ * enumerator that omits them — this adapter keeps that under-report default
+ * so one session's private records are never mirrored into the shared,
+ * project-scoped vector store.
+ */
+import type { SageSurface } from '@wrongstack/sage';
+import type { SageSyncSource } from './store.js';
+export interface SageSurfaceSyncOptions {
+    /**
+     * Hard cap on total mirrored memories. Omit (or set to `Infinity`) to
+     * walk the entire active corpus. Useful for tests that want a bounded
+     * walk without depending on `nextCursor` termination.
+     */
+    maxTotal?: number | undefined;
+    /** Page size per `listSagePage` call. Clamped to [1, 500]. */
+    pageSize?: number | undefined;
+}
+/**
+ * Build a `SageSyncSource` from any SAGE surface exposing `listSagePage`.
+ * The surface capability is obtained via `getSageSurface(memoryPort)` from
+ * `@wrongstack/sage`; a `Pick` keeps this adapter honest about what it calls.
+ */
+export declare function createSageSurfaceSyncSource(sage: Pick<SageSurface, 'listSagePage'>, opts?: SageSurfaceSyncOptions): SageSyncSource;
+//# sourceMappingURL=sage-sync-source.d.ts.map

package/dist/sage-sync.d.ts

@@ -0,0 +1,55 @@
+import type { MemoryPort } from '@wrongstack/core/types';
+import type { VectorMemoryStore } from './store.js';
+/** Sync marker file written next to the vector db (`running` → `complete` phases). */
+export declare const SAGE_SYNC_MARKER_FILENAME = "sage-sync.complete.json";
+export interface SageSyncMarker {
+    phase: 'running' | 'complete';
+    pid?: number;
+    startedAt?: string;
+    completedAt?: string;
+    providerId?: string;
+    scanned?: number;
+    indexed?: number;
+    skipped?: number;
+    failed?: number;
+}
+export interface FirstBootSageSyncOptions {
+    store: VectorMemoryStore;
+    /** The host MemoryPort — the SAGE surface capability is read from it. */
+    memoryStore: MemoryPort;
+    /** Structurally compatible with `@wrongstack/core`'s `Logger`. */
+    logger?: {
+        debug?(msg: string, ctx?: unknown): void | undefined;
+        info?(msg: string, ctx?: unknown): void | undefined;
+        warn?(msg: string, ctx?: unknown): void | undefined;
+    } | undefined;
+    /** Tests: inject a custom staleness window. */
+    staleAfterMs?: number | undefined;
+    /**
+     * Tests / hosts: pid liveness probe used before taking over a `running`
+     * marker. Defaults to `process.kill(pid, 0)` — throws for a dead pid.
+     */
+    pidAlive?: ((pid: number) => boolean) | undefined;
+    /**
+     * Force a full re-sync, ignoring any `complete` marker from a prior
+     * boot. Used by operator-initiated re-sync (CLI flag, slash command)
+     * where the user explicitly opted in to replay. The new sync still
+     * respects the cursor-walker's own termination and the completion
+     * invariant (every entry has a vector) — `force` only bypasses the
+     * "already-complete, skip" decision.
+     */
+    force?: boolean | undefined;
+}
+export interface FirstBootSageSyncResult {
+    synced: boolean;
+    reason: string;
+    marker?: SageSyncMarker | undefined;
+}
+export declare function startFirstBootSageSync(opts: FirstBootSageSyncOptions): Promise<FirstBootSageSyncResult>;
+interface SyncDecision {
+    run: boolean;
+    reason: string;
+}
+export declare function decideWhetherToSync(store: VectorMemoryStore, staleAfterMs: number, now?: Date, pidAlive?: (pid: number) => boolean): SyncDecision;
+export {};
+//# sourceMappingURL=sage-sync.d.ts.map

package/dist/schema.d.ts

@@ -1,19 +1,43 @@
 /**
  * SQLite schema for the vector memory store.
  *
- * Two tables:
- *  - `entries` — text + metadata, no embedding column
- *  - `vectors` — (entry_id, provider_id) PK, raw float32 blob
+ * Tables:
+ *  - `entries` — text + metadata, no embedding column.
+ *  - `vectors` — (entry_id, provider_id) PK, raw float32 blob.
+ *  - `embedding_cache` — provider-level text→vector cache so repeated
+ *    `embed()` calls for the same text skip the ONNX forward pass. Keyed
+ *    by (content_hash, provider_id, model_dimensions) so a model swap
+ *    invalidates only the old provider rows on insert — no mixed-vector
+ *    search. Independent of `entries`, so the cache survives entry deletes.
+ *  - `schema_meta` — active provider id and dimensions.
  *
  * The vectors table is keyed by (entry_id, provider_id) so a model swap
  * invalidates only the old provider rows on insert — no mixed-vector search.
- * A companion `schema_meta` table records the active provider id and dims.
  */
 import type { DatabaseSync } from 'node:sqlite';
-export declare const VECTOR_SCHEMA_VERSION = 1;
+export declare const VECTOR_SCHEMA_VERSION = 2;
 export declare const VECTOR_PROVIDER_KEY = "active_provider_id";
 export declare const VECTOR_DIMENSIONS_KEY = "active_provider_dimensions";
 export declare function initVectorSchema(db: DatabaseSync): void;
+/**
+ * Upsert a vector into the embedding cache. `use_count` increments on
+ * conflict so hot texts can be identified later. `last_used_at` advances
+ * to the current timestamp on every hit so LRU eviction has something to
+ * read.
+ */
+export declare function upsertEmbeddingCache(db: DatabaseSync, row: {
+    contentHash: string;
+    providerId: string;
+    dimensions: number;
+    vector: Buffer;
+    text: string;
+    now: string;
+}): void;
+/**
+ * Look up a vector in the cache. Returns the decoded vector and bumps
+ * `last_used_at` / `use_count` atomically. Returns undefined on miss.
+ */
+export declare function lookupEmbeddingCache(db: DatabaseSync, contentHash: string, providerId: string, dimensions: number, now: string): Float32Array | undefined;
 /** Encode a Float32Array to a SQLite BLOB (Buffer). */
 export declare function encodeVector(vec: Float32Array): Buffer;
 /** Decode a SQLite BLOB (Buffer or Uint8Array) back to a Float32Array. */

package/dist/search-race.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Search-channel race — run a query through SAGE (lexical) and the
+ * vector store (semantic) independently and surface the overlap and
+ * the channel-specific misses. The point of the dual system is
+ * precisely this comparison: the operator can SEE that one channel
+ * caught a memory the other missed, and tune the RRF weight
+ * accordingly.
+ *
+ * The output is structured for two consumers:
+ *  - The WebUI's memory panel uses the `channels` / `overlap` arrays
+ *    to render a side-by-side breakdown.
+ *  - The CLI `/memory race <query>` command renders a human-readable
+ *    summary via `formatSearchRace` in `@wrongstack/cli`.
+ *
+ * Race is read-only. No writes to either store.
+ */
+import type { Sage } from '@wrongstack/sage';
+import type { VectorMemoryStore } from './store.js';
+export interface SearchRaceChannelHit {
+    /** SAGE memory id (the join key — both channels index the same corpus). */
+    id: string;
+    /** Lexical rank score (0..1) — null on the vector channel. */
+    lexicalScore: number | null;
+    /** Vector cosine (0..1) — null on the lexical channel. */
+    vectorScore: number | null;
+    /** Truncated text preview, for human-readable output. */
+    preview: string;
+}
+export interface SearchRaceResult {
+    query: string;
+    lexicalOnly: SearchRaceChannelHit[];
+    vectorOnly: SearchRaceChannelHit[];
+    overlap: Array<{
+        id: string;
+        lexicalScore: number;
+        vectorScore: number;
+        preview: string;
+    }>;
+    /**
+     * Summary metrics — the whole point of the race is to surface
+     * "what would the user have missed if they had only run one
+     * channel?" Each ratio is a 0..1 number.
+     */
+    metrics: {
+        /** Memories found by the lexical channel (incl. overlap). */
+        lexicalCount: number;
+        /** Memories found by the vector channel (incl. overlap). */
+        vectorCount: number;
+        /** Memories found by both. */
+        overlapCount: number;
+        /** `lexicalOnly / lexicalCount` — how much of lexical recall is invisible to vector. */
+        lexicalOnlyRatio: number;
+        /** `vectorOnly / vectorCount` — how much of vector recall is invisible to lexical. */
+        vectorOnlyRatio: number;
+        /** `overlapCount / max(lexicalCount, vectorCount)` — agreement rate. */
+        agreementRatio: number;
+    };
+}
+export interface SearchRaceOptions {
+    /** Cap on each channel's result set. Default 20. */
+    limit?: number | undefined;
+    /** Cosine threshold forwarded to `vectorStore.search`. Default 0. */
+    threshold?: number | undefined;
+}
+/**
+ * Run the same query through both channels and compute the overlap.
+ * Lexical hits come from the caller (the SAGE surface). Vector hits
+ * are queried from the supplied `vectorStore`. Memories are joined
+ * by SAGE id, so the race is only meaningful when the vector store
+ * has been warm-started via the SAGE mirror.
+ *
+ * No writes. No events emitted. Safe to run on every TUI refresh.
+ */
+export declare function runSearchRace(query: string, lexical: readonly Sage[], vectorStore: VectorMemoryStore, options?: SearchRaceOptions): Promise<SearchRaceResult>;
+//# sourceMappingURL=search-race.d.ts.map

package/dist/store.d.ts

@@ -3,15 +3,72 @@ import type { SageSyncReport, VectorEntry, VectorEntryInput, VectorEntryWithVect
 export declare class VectorMemoryStore {
     private readonly db;
     private readonly dbPath;
+    private readonly rootDir;
     private readonly provider;
     private closed;
     constructor(opts: VectorMemoryStoreOptions);
+    /**
+     * Absolute path of the store's data directory (the resolved
+     * `opts.directory`, default `.wrongstack/vector-memory`). Hosts use this
+     * to place sidecar state (e.g. the first-boot SAGE sync marker) next to
+     * the db instead of re-deriving the path and drifting from it.
+     */
+    get directory(): string;
+    /**
+     * Absolute path of the SQLite database file. Hosts use this to take a
+     * file-level lock that covers all mutating operations (see
+     * `withFileLock(this.dbPath + '.lock', …)`).
+     */
+    get databasePath(): string;
+    /** The lockfile path used to serialize mutating operations. */
+    get lockPath(): string;
     get activeProviderId(): string;
     private recordActiveProvider;
     static contentHash(text: string): string;
+    /**
+     * Look up a vector for `text` in the provider-level embedding cache.
+     * Cache hit returns the cached vector (no ONNX pass). Miss returns
+     * `undefined`.
+     */
+    private cachedVector;
+    /** Persist `vec` for `text` to the embedding cache. */
+    private cacheVector;
+    /**
+     * Embed `text`, hitting the provider-level cache first. Cache miss falls
+     * through to the configured provider and writes the result back. Returns
+     * `undefined` when the provider fails — the caller can persist the entry
+     * without a vector (fail-open).
+     */
+    private embedWithCache;
+    /**
+     * Look up an existing entry by `content_hash`. Returns `undefined` when
+     * the entry is not present. Used by `remember()` to make writes idempotent
+     * and by `syncFromSage()` to skip already-indexed SAGE memories.
+     */
+    findByContentHash(contentHash: string): VectorEntryWithVector | undefined;
+    /**
+     * Look up the entry mirroring a given SAGE memory id (i.e. the entry
+     * whose `metadata.sageId` equals `sageId`). Returns `undefined` when
+     * no such entry exists. Used by the event-driven mirror to delete
+     * vector entries on SAGE delete events (the emitter knows the SAGE
+     * id, not the vector entry id).
+     *
+     * Index lookup is `json_extract(metadata, '$.sageId')` — the metadata
+     * column is the JSON blob `syncFromSage` writes, so this avoids a
+     * full table scan.
+     */
+    findBySageId(sageId: string): VectorEntryWithVector | undefined;
+    /**
+     * Persist a new entry. Idempotent: if an entry with the same
+     * `content_hash` already exists, that entry is returned unchanged
+     * instead of inserting a duplicate. Mutating ops are wrapped in
+     * `withFileLock` so two processes cannot race the dedup check.
+     */
     remember(input: VectorEntryInput): Promise<VectorEntryWithVector>;
+    private rememberUnlocked;
     get(id: string): VectorEntryWithVector | undefined;
-    forget(id: string): boolean;
+    /** Hard-delete an entry by id. Wrapped in `withFileLock` for cross-process safety. */
+    forget(id: string): Promise<boolean>;
     search(query: string, opts?: VectorSearchOptions): Promise<VectorSearchHit[]>;
     list(opts?: {
         limit?: number;
@@ -23,6 +80,26 @@ export declare class VectorMemoryStore {
         errors: number;
     }>;
     stats(): VectorStoreStats;
+    /**
+     * Embedding-cache diagnostics — entries, hit/miss counters, oldest entry.
+     * Useful for the WebUI's vector-memory panel and for diagnosing the
+     * "why is search slow?" question.
+     */
+    cacheStats(): {
+        entries: number;
+        providers: number;
+        totalUseCount: number;
+        oldestLastUsedAt: string | null;
+    };
+    /**
+     * LRU-evict the embedding cache down to `keepMostRecent` rows. The
+     * `embedding_cache` table is independent of `entries`, so a sweep here
+     * only removes cached vectors — never stored entries. Called by hosts
+     * that want to bound cache growth on long-lived processes.
+     */
+    evictCache(keepMostRecent: number): Promise<{
+        removed: number;
+    }>;
     close(): void;
     private assertOpen;
     private rowToEntry;

package/dist/types.d.ts

@@ -48,12 +48,27 @@ export interface VectorSearchOptions {
     kind?: VectorKind | undefined;
     /** Provider id override for the query embedding. Defaults to the store's provider. */
     providerId?: string | undefined;
+    /**
+     * When true, each returned hit also carries the decoded embedding
+     * vector. Off by default to keep the response small. Used by the
+     * webui-server's `/api/vector-memory/search?similarity=1` route to
+     * build the pairwise-similarity heatmap.
+     */
+    includeVectors?: boolean | undefined;
 }
 export interface VectorSearchHit {
     entry: VectorEntry;
     /** Cosine similarity in [-1, 1]. The store clamps to [0, 1] before returning. */
     score: number;
     providerId: string;
+    /**
+     * Decoded embedding vector for the matched entry. Populated only when
+     * the caller passes `includeVectors: true` to `store.search()` — keeps
+     * the default response small. Useful for downstream consumers that
+     * need pairwise similarity (e.g. WebUI heatmap) without a second
+     * `get(id)` round-trip.
+     */
+    vector?: Float32Array | undefined;
 }
 export interface VectorStoreStats {
     entries: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/vector-memory",
-  "version": "0.308.0",
+  "version": "0.308.2",
   "license": "MIT",
   "description": "WrongStack Vector Memory — an additional vector-search memory store powered by @huggingface/transformers (local ONNX embeddings), alongside the SAGE lexical memory system.",
   "repository": {
@@ -27,8 +27,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@wrongstack/core": "0.308.0",
-    "@wrongstack/sage": "0.308.0"
+    "@wrongstack/sage": "0.308.2",
+    "@wrongstack/core": "0.308.2"
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^4.2.0"