@wrongstack/vector-memory 0.308.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ECOSTACK TECHNOLOGY OÜ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,189 @@
+# @wrongstack/vector-memory
+
+An **additional vector-search memory** that sits alongside the existing
+SAGE lexical memory system. Embeddings are computed locally via
+[@huggingface/transformers](https://github.com/huggingface/transformers.js)
+using the `Xenova/all-MiniLM-L6-v2` ONNX model (384 dimensions, ~25 MB
+quantized). No project text leaves the machine.
+
+The store is deliberately separate from SAGE's SQLite database — its own
+file under `.wrongstack/vector-memory/vector-memory.db` — so the two
+stores cannot contend on the same file lock. A built-in `syncFromSage`
+bridge indexes active SAGE memories into the vector store, giving
+semantic search over your existing knowledge.
+
+## Installation
+
+`@huggingface/transformers` is listed as an **optional** dependency so
+the package installs and typechecks even without it. In this monorepo
+it's installed by default; in downstream packages, ensure it's present:
+
+```sh
+pnpm add @huggingface/transformers
+```
+
+The package itself is a workspace member; no extra install step is
+needed inside the monorepo.
+
+## Quick start
+
+```ts
+import {
+  TransformersEmbeddingProvider,
+  VectorMemoryStore,
+  createVectorMemoryTools,
+} from '@wrongstack/vector-memory';
+import path from 'node:path';
+
+const provider = new TransformersEmbeddingProvider({
+  // Optional overrides (these are the defaults):
+  modelId: 'Xenova/all-MiniLM-L6-v2',
+  cacheDir: path.join(projectRoot, '.wrongstack/vector-memory/models'),
+  dtype: 'q8',
+  device: 'cpu',
+  allowRemoteModels: true, // set false to require a pre-cached model
+});
+
+const store = new VectorMemoryStore({ provider, projectRoot });
+
+await store.remember({ text: 'pnpm is the package manager', tags: ['build'] });
+
+const hits = await store.search('how do we install dependencies', { limit: 5 });
+//   → hits[i].entry.text, hits[i].score (cosine similarity in [0, 1])
+
+store.close();
+```
+
+## Tools
+
+`createVectorMemoryTools(store)` returns four `@wrongstack/core` `Tool`
+definitions that surface the store to agents:
+
+| Tool | Permission | Mutating | Purpose |
+|------|------------|----------|---------|
+| `vector_memory_remember` | `confirm` | yes | Store text + embed it |
+| `vector_memory_search` | `auto` | no | Semantic top-k search |
+| `vector_memory_stats` | `auto` | no | Entry/vector/provider counts |
+| `vector_memory_forget` | `confirm` | yes | Hard-delete an entry by id |
+
+Wire them alongside `createSageTools` if you want agents to have both
+the lexical and the semantic memory surface.
+
+## Graceful fallback
+
+`TransformersEmbeddingProvider` is lazy — nothing is imported until the
+first `embed()` call. If `@huggingface/transformers` is not installed
+or the model fails to load (offline, corrupt cache, etc.):
+
+- `isAvailable()` returns `false`.
+- `embed()` throws `VectorMemoryProviderUnavailableError` (or a wrapped
+  underlying error from the pipeline).
+- The store's `remember()` **swallows** the embedding failure and
+  persists the entry without a vector. Search simply skips entries
+  without a matching vector row. Writes never disappear.
+- `search()` returns `[]` when embedding fails, so callers can fall
+  back to lexical search at a higher layer.
+
+For an offline-only store, wire the sage `HashingEmbeddingProvider`
+instead — it's deterministic, zero-dependency, and satisfies the same
+`EmbeddingProvider` contract:
+
+```ts
+import { HashingEmbeddingProvider, type EmbeddingProvider } from '@wrongstack/sage';
+
+const provider: EmbeddingProvider = new HashingEmbeddingProvider({ dimensions: 384 });
+```
+
+The store accepts any `EmbeddingProvider`; you can mix and match
+between providers across instances or for testing.
+
+## Syncing with SAGE
+
+```ts
+const sagePort = /* a MemoryPort or any object satisfying SageSyncSource */;
+const report = await store.syncFromSage({
+  listActiveMemories: async ({ limit }) => {
+    const page = await sagePort.listSagePage({ statuses: ['active'], limit });
+    return (page.memories ?? []).map((m) => ({
+      id: m.id,
+      text: m.text,
+      tags: m.tags,
+    }));
+  },
+});
+// { scanned, indexed, skipped, failed, errors }
+```
+
+The bridge deduplicates on `contentHash` (SHA-256 of NFKC-normalized
+text) so repeated calls are idempotent.
+
+## Storage layout
+
+```
+<projectRoot>/.wrongstack/vector-memory/
+├── vector-memory.db          — SQLite database (WAL mode)
+├── vector-memory.db-wal      — WAL frame file
+└── models/                   — transformers.js model cache (when configured)
+```
+
+The model cache defaults to `.wrongstack/vector-memory/models` under
+the project root; override via `TransformersEmbeddingProvider({ cacheDir })`.
+Set `allowRemoteModels: false` to refuse downloads and require a
+pre-populated cache (useful in CI / air-gapped runs).
+
+## Schema
+
+- `entries` — text, summary, metadata JSON, tags JSON, scope, kind,
+  content_hash, timestamps. Indexed on scope/kind/hash/updated_at.
+- `vectors` — `(entry_id, provider_id)` PK, dimensions, raw float32
+  BLOB, timestamp. Foreign-key cascades on entry delete. Provider-id
+  keying means a model change triggers reindexing rather than mixed
+  vectors.
+- `entries_fts` — FTS5 mirror of `text` + `tags` for the optional
+  lexical fallback path. Kept in sync via triggers.
+- `schema_meta` — active provider id and dimensions.
+
+## API reference
+
+- `VectorMemoryStore` — constructor `({ provider, projectRoot, directory?, filename? })`.
+- `remember(input)` → `VectorEntryWithVector`
+- `get(id)` → `VectorEntryWithVector | undefined`
+- `forget(id)` → `boolean`
+- `search(query, opts?)` → `VectorSearchHit[]`
+- `list(opts?)` → `VectorEntry[]`
+- `stats()` → `VectorStoreStats`
+- `reindexAll()` → `{ processed, errors }`
+- `syncFromSage(source)` → `SageSyncReport`
+- `activeProviderId` → `string`
+- `close()`
+
+See `src/types.ts` for the full type surface.
+
+## Testing
+
+Tests use a deterministic `FakeEmbeddingProvider` — no network, no
+model download. Run:
+
+```sh
+pnpm --filter @wrongstack/vector-memory test
+```
+
+The integration path that exercises the real transformers.js pipeline
+is not included in the default test suite because it requires model
+download. To exercise it manually:
+
+```ts
+import { TransformersEmbeddingProvider } from '@wrongstack/vector-memory';
+const p = new TransformersEmbeddingProvider();
+console.log(await p.isAvailable()); // true when @huggingface/transformers is installed
+const [vec] = await p.embed(['hello world']);
+console.log(vec.length); // 384
+```
+
+## Related
+
+- `@wrongstack/sage` — lexical/FTS/graph memory. `EmbeddingProvider` and
+  `cosineSimilarity` are exported from sage so any package can implement
+  or compose with them.
+- `docs/competitive-roadmap-2026-2027/13-semantic-sage-retrieval.md` —
+  the roadmap doc this package implements a subset of.

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Error types for the vector memory package.
+ *
+ * Kept in their own module so callers can `instanceof`-check without
+ * pulling the full store implementation.
+ */
+export declare class VectorMemoryError extends Error {
+    constructor(message: string);
+}
+/**
+ * Raised when the configured embedding provider is unavailable — typically
+ * because `@huggingface/transformers` was not installed or the model
+ * failed to load. The original cause (if any) is attached for diagnostics.
+ */
+export declare class VectorMemoryProviderUnavailableError extends VectorMemoryError {
+    readonly cause: unknown;
+    constructor(message: string, cause?: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @wrongstack/vector-memory — public exports.
+ */
+export { DEFAULT_VECTOR_DIMENSIONS, DEFAULT_VECTOR_DTYPE, DEFAULT_VECTOR_MODEL_ID, TransformersEmbeddingProvider, type TransformersEmbeddingProviderOptions, } from './transformers-provider.js';
+export { VECTOR_DIMENSIONS_KEY, VECTOR_PROVIDER_KEY, VECTOR_SCHEMA_VERSION, decodeVector, encodeVector, initVectorSchema, } from './schema.js';
+export { VectorMemoryStore, fallbackHashingProvider, type SageSyncSource, } from './store.js';
+export { createVectorMemoryTools } from './tools.js';
+export type { SageSyncReport, VectorEntry, VectorEntryInput, VectorEntryWithVector, VectorKind, VectorMemoryStoreOptions, VectorScope, VectorSearchHit, VectorSearchOptions, VectorStoreStats, } from './types.js';
+export { VectorMemoryError, VectorMemoryProviderUnavailableError, } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,729 @@
+// src/errors.ts
+var VectorMemoryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VectorMemoryError";
+  }
+};
+var VectorMemoryProviderUnavailableError = class extends VectorMemoryError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "VectorMemoryProviderUnavailableError";
+    this.cause = cause;
+  }
+};
+
+// src/transformers-provider.ts
+var DEFAULT_VECTOR_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+var DEFAULT_VECTOR_DIMENSIONS = 384;
+var DEFAULT_VECTOR_DTYPE = "q8";
+var TransformersEmbeddingProvider = class {
+  id;
+  dimensions;
+  modelId;
+  cacheDir;
+  dtype;
+  device;
+  batchSize;
+  maxChars;
+  allowRemote;
+  extractor;
+  loadPromise;
+  constructor(opts = {}) {
+    this.modelId = opts.modelId ?? DEFAULT_VECTOR_MODEL_ID;
+    this.cacheDir = opts.cacheDir;
+    this.dtype = opts.dtype ?? DEFAULT_VECTOR_DTYPE;
+    this.device = opts.device ?? "cpu";
+    this.batchSize = opts.batchSize ?? 16;
+    this.maxChars = opts.maxChars ?? 2048;
+    this.allowRemote = opts.allowRemoteModels ?? true;
+    this.dimensions = DEFAULT_VECTOR_DIMENSIONS;
+    this.id = `transformers-js:${this.modelId}:${this.dtype}`;
+  }
+  /**
+   * Synchronous capability check. Returns false when the optional
+   * `@huggingface/transformers` dependency is not installed.
+   *
+   * NOTE: this probes via dynamic import and caches the result, but does
+   * NOT load the model itself — model loading is deferred to `embed()`.
+   */
+  async isAvailable() {
+    try {
+      await this.loadModule();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    const extractor = await this.getExtractor();
+    const prepared = texts.map((t) => this.prepare(t));
+    const batches = [];
+    for (let i = 0; i < prepared.length; i += this.batchSize) {
+      batches.push(prepared.slice(i, i + this.batchSize));
+    }
+    const results = [];
+    for (const batch of batches) {
+      const out = await extractor(batch, { pooling: "mean", normalize: true });
+      results.push(...this.tensorToVectors(out, batch.length));
+    }
+    return results;
+  }
+  /** Truncate + normalize text before embedding. */
+  prepare(text) {
+    if (!text) return "";
+    const normalized = text.normalize("NFKC").trim();
+    return normalized.length > this.maxChars ? normalized.slice(0, this.maxChars) : normalized;
+  }
+  tensorToVectors(out, batchSize) {
+    if (typeof out.tolist === "function") {
+      const nested = out.tolist();
+      if (Array.isArray(nested) && Array.isArray(nested[0])) {
+        return nested.map((row) => Float32Array.from(row));
+      }
+      return [Float32Array.from(nested)];
+    }
+    const flat = out.data;
+    if (flat instanceof Float32Array) {
+      if (batchSize === 1) return [flat];
+      const dim = flat.length / batchSize;
+      const vectors = [];
+      for (let i = 0; i < batchSize; i++) {
+        vectors.push(Float32Array.from(flat.subarray(i * dim, (i + 1) * dim)));
+      }
+      return vectors;
+    }
+    if (Array.isArray(flat) && Array.isArray(flat[0])) {
+      return flat.map((row) => Float32Array.from(row));
+    }
+    if (Array.isArray(flat)) {
+      return [Float32Array.from(flat)];
+    }
+    throw new Error("TransformersEmbeddingProvider: unexpected pipeline output shape");
+  }
+  async getExtractor() {
+    if (this.extractor) return this.extractor;
+    if (!this.loadPromise) this.loadPromise = this.loadExtractor();
+    this.extractor = await this.loadPromise;
+    return this.extractor;
+  }
+  async loadExtractor() {
+    const mod = await this.loadModule();
+    if (this.cacheDir) mod.env.cacheDir = this.cacheDir;
+    mod.env.allowRemoteModels = this.allowRemote;
+    if (!this.allowRemote) mod.env.localModelPath = this.cacheDir ?? "";
+    const pipe = await mod.pipeline("feature-extraction", this.modelId, {
+      dtype: this.dtype,
+      device: this.device
+    });
+    return pipe;
+  }
+  async loadModule() {
+    try {
+      return await import("@huggingface/transformers");
+    } catch (err) {
+      throw new VectorMemoryProviderUnavailableError(
+        "@huggingface/transformers is not installed. Install it (pnpm add @huggingface/transformers) or wire a fallback EmbeddingProvider.",
+        err
+      );
+    }
+  }
+};
+
+// src/schema.ts
+var VECTOR_SCHEMA_VERSION = 1;
+var VECTOR_PROVIDER_KEY = "active_provider_id";
+var VECTOR_DIMENSIONS_KEY = "active_provider_dimensions";
+function initVectorSchema(db) {
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA synchronous = NORMAL");
+  db.exec("PRAGMA busy_timeout = 30000");
+  db.exec("PRAGMA temp_store = MEMORY");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries (
+      id TEXT PRIMARY KEY,
+      text TEXT NOT NULL,
+      summary TEXT,
+      metadata TEXT NOT NULL DEFAULT '{}',
+      tags TEXT NOT NULL DEFAULT '[]',
+      scope TEXT NOT NULL DEFAULT 'project',
+      kind TEXT NOT NULL DEFAULT 'note',
+      content_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_entries_scope ON entries(scope)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_entries_kind ON entries(kind)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_entries_hash ON entries(content_hash)");
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_entries_updated ON entries(updated_at DESC)"
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS vectors (
+      entry_id TEXT NOT NULL,
+      provider_id TEXT NOT NULL,
+      dimensions INTEGER NOT NULL,
+      vector BLOB NOT NULL,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (entry_id, provider_id),
+      FOREIGN KEY (entry_id) REFERENCES entries(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_vectors_provider ON vectors(provider_id)");
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(
+      id UNINDEXED, text, tags, content='entries', content_rowid='rowid'
+    );
+  `);
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS entries_ai AFTER INSERT ON entries BEGIN
+      INSERT INTO entries_fts(rowid, text, tags)
+      VALUES (new.rowid, new.text, new.tags);
+    END;
+  `);
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS entries_ad AFTER DELETE ON entries BEGIN
+      INSERT INTO entries_fts(entries_fts, rowid, text, tags)
+      VALUES('delete', old.rowid, old.text, old.tags);
+    END;
+  `);
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS entries_au AFTER UPDATE ON entries BEGIN
+      INSERT INTO entries_fts(entries_fts, rowid, text, tags)
+      VALUES('delete', old.rowid, old.text, old.tags);
+      INSERT INTO entries_fts(rowid, text, tags)
+      VALUES (new.rowid, new.text, new.tags);
+    END;
+  `);
+}
+function encodeVector(vec) {
+  return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+function decodeVector(buf) {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  const copy = new Float32Array(buf.byteLength / 4);
+  for (let i = 0; i < copy.length; i++) {
+    copy[i] = view.getFloat32(i * 4, true);
+  }
+  return copy;
+}
+
+// src/store.ts
+import { createHash, randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { HashingEmbeddingProvider, cosineSimilarity } from "@wrongstack/sage";
+var DEFAULT_DIRECTORY = ".wrongstack/vector-memory";
+var DEFAULT_FILENAME = "vector-memory.db";
+var VectorMemoryStore = class _VectorMemoryStore {
+  db;
+  dbPath;
+  provider;
+  closed = false;
+  constructor(opts) {
+    if (!opts.provider) throw new Error("VectorMemoryStore: provider is required");
+    if (!opts.projectRoot) throw new Error("VectorMemoryStore: projectRoot is required");
+    this.provider = opts.provider;
+    const dir = opts.directory ?? DEFAULT_DIRECTORY;
+    const filename = opts.filename ?? DEFAULT_FILENAME;
+    if (path.isAbsolute(dir)) {
+      throw new Error("Vector memory directory must be project-relative.");
+    }
+    const rootDir = path.resolve(opts.projectRoot, dir);
+    const rel = path.relative(path.resolve(opts.projectRoot), rootDir);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+      throw new Error("Vector memory directory must stay inside the project root.");
+    }
+    fs.mkdirSync(rootDir, { recursive: true });
+    this.dbPath = path.join(rootDir, filename);
+    this.db = new DatabaseSync(this.dbPath);
+    initVectorSchema(this.db);
+    this.recordActiveProvider();
+  }
+  get activeProviderId() {
+    const row = this.db.prepare("SELECT value FROM schema_meta WHERE key = ?").get(VECTOR_PROVIDER_KEY);
+    return row?.value ?? this.provider.id;
+  }
+  recordActiveProvider() {
+    this.db.exec("BEGIN");
+    try {
+      this.db.prepare(
+        `INSERT INTO schema_meta (key, value) VALUES (?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+      ).run(VECTOR_PROVIDER_KEY, this.provider.id);
+      this.db.prepare(
+        `INSERT INTO schema_meta (key, value) VALUES (?, ?)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+      ).run(VECTOR_DIMENSIONS_KEY, String(this.provider.dimensions));
+      this.db.exec("COMMIT");
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  static contentHash(text) {
+    return createHash("sha256").update(text.normalize("NFKC").trim()).digest("hex");
+  }
+  async remember(input) {
+    this.assertOpen();
+    if (!input.text || input.text.trim().length === 0) {
+      throw new Error("VectorMemoryStore.remember: text must be non-empty");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = randomUUID();
+    const contentHash = _VectorMemoryStore.contentHash(input.text);
+    const metadata = input.metadata ?? {};
+    const tags = input.tags ?? [];
+    const scope = input.scope ?? "project";
+    const kind = input.kind ?? "note";
+    let vector;
+    let providerId;
+    try {
+      const result2 = await this.provider.embed([input.text]);
+      vector = result2[0];
+      providerId = this.provider.id;
+    } catch {
+      providerId = void 0;
+      vector = void 0;
+    }
+    this.db.exec("BEGIN");
+    try {
+      this.db.prepare(
+        `INSERT INTO entries
+            (id, text, summary, metadata, tags, scope, kind, content_hash, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        id,
+        input.text,
+        input.summary ?? null,
+        JSON.stringify(metadata),
+        JSON.stringify(tags),
+        scope,
+        kind,
+        contentHash,
+        now,
+        now
+      );
+      if (vector && providerId) {
+        this.db.prepare(
+          `INSERT INTO vectors (entry_id, provider_id, dimensions, vector, created_at)
+             VALUES (?, ?, ?, ?, ?)
+             ON CONFLICT(entry_id, provider_id) DO UPDATE SET
+               vector = excluded.vector,
+               dimensions = excluded.dimensions,
+               created_at = excluded.created_at`
+        ).run(id, providerId, vector.length, encodeVector(vector), now);
+      }
+      this.db.exec("COMMIT");
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
+    const result = {
+      id,
+      text: input.text,
+      summary: input.summary ?? void 0,
+      metadata,
+      tags,
+      scope,
+      kind,
+      contentHash,
+      createdAt: now,
+      updatedAt: now,
+      providerId: providerId ?? "",
+      dimensions: vector?.length ?? 0
+    };
+    if (vector) result.vector = vector;
+    return result;
+  }
+  get(id) {
+    this.assertOpen();
+    const row = this.db.prepare("SELECT * FROM entries WHERE id = ?").get(id);
+    if (!row) return void 0;
+    const vectorRow = this.db.prepare("SELECT * FROM vectors WHERE entry_id = ?").get(id);
+    return this.rowToEntry(row, vectorRow);
+  }
+  forget(id) {
+    this.assertOpen();
+    this.db.exec("BEGIN");
+    try {
+      const info = this.db.prepare("DELETE FROM entries WHERE id = ?").run(id);
+      this.db.exec("COMMIT");
+      return info.changes > 0;
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  async search(query, opts = {}) {
+    this.assertOpen();
+    const limit = opts.limit ?? 10;
+    const threshold = opts.threshold ?? 0;
+    if (typeof query !== "string" || query.trim().length === 0) return [];
+    let queryVec;
+    try {
+      const result = await this.provider.embed([query]);
+      if (!result[0]) return [];
+      queryVec = result[0];
+    } catch {
+      return [];
+    }
+    if (!queryVec || queryVec.length === 0) return [];
+    const providerId = this.provider.id;
+    const dimensions = this.provider.dimensions;
+    const filters = ["v.provider_id = ?", "v.dimensions = ?"];
+    const params = [providerId, dimensions];
+    if (opts.scope !== void 0) {
+      filters.push("e.scope = ?");
+      params.push(opts.scope);
+    }
+    if (opts.kind !== void 0) {
+      filters.push("e.kind = ?");
+      params.push(opts.kind);
+    }
+    const rows = this.db.prepare(
+      `SELECT e.id, e.text, e.summary, e.metadata, e.tags, e.scope, e.kind,
+                e.content_hash, e.created_at, e.updated_at,
+                v.vector AS vec_blob
+           FROM entries e
+           JOIN vectors v ON v.entry_id = e.id
+          WHERE ${filters.join(" AND ")}`
+    ).all(...params);
+    const scored = [];
+    for (const row of rows) {
+      const blob = row.vec_blob;
+      const vec = decodeVector(blob);
+      const raw = cosineSimilarity(queryVec, vec);
+      const score = Math.max(0, Math.min(1, raw));
+      if (score < threshold) continue;
+      const entry = this.rowToEntry(row);
+      scored.push({ entry, score, providerId });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit);
+  }
+  list(opts = {}) {
+    this.assertOpen();
+    const where = [];
+    const params = [];
+    if (opts.scope !== void 0) {
+      where.push("scope = ?");
+      params.push(opts.scope);
+    }
+    if (opts.kind !== void 0) {
+      where.push("kind = ?");
+      params.push(opts.kind);
+    }
+    const sql = `SELECT * FROM entries ${where.length ? `WHERE ${where.join(" AND ")}` : ""}
+                 ORDER BY updated_at DESC LIMIT ?`;
+    params.push(opts.limit ?? 100);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => this.rowToEntry(r));
+  }
+  async reindexAll() {
+    this.assertOpen();
+    const rows = this.db.prepare("SELECT id, text FROM entries").all();
+    let processed = 0;
+    let errors = 0;
+    for (const row of rows) {
+      try {
+        const result = await this.provider.embed([row.text]);
+        const v = result[0];
+        if (!v) {
+          errors++;
+          continue;
+        }
+        this.db.prepare(
+          `INSERT INTO vectors (entry_id, provider_id, dimensions, vector, created_at)
+             VALUES (?, ?, ?, ?, ?)
+             ON CONFLICT(entry_id, provider_id) DO UPDATE SET
+               vector = excluded.vector,
+               dimensions = excluded.dimensions,
+               created_at = excluded.created_at`
+        ).run(
+          row.id,
+          this.provider.id,
+          v.length,
+          encodeVector(v),
+          (/* @__PURE__ */ new Date()).toISOString()
+        );
+        processed++;
+      } catch {
+        errors++;
+      }
+    }
+    return { processed, errors };
+  }
+  stats() {
+    this.assertOpen();
+    const entryCount = this.db.prepare("SELECT COUNT(*) AS n FROM entries").get().n;
+    const vectorCount = this.db.prepare("SELECT COUNT(*) AS n FROM vectors").get().n;
+    const providerRows = this.db.prepare("SELECT DISTINCT provider_id FROM vectors").all();
+    return {
+      entries: entryCount,
+      vectors: vectorCount,
+      providers: providerRows.map((r) => r.provider_id),
+      modelAvailable: true,
+      modelId: this.provider.id,
+      dimensions: this.provider.dimensions
+    };
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.db.close();
+  }
+  assertOpen() {
+    if (this.closed) throw new Error("VectorMemoryStore is closed");
+  }
+  rowToEntry(row, vectorRow) {
+    const summaryValue = row.summary;
+    const entry = {
+      id: row.id,
+      text: row.text,
+      summary: summaryValue ?? void 0,
+      metadata: safeParseJson(row.metadata, {}),
+      tags: safeParseJson(row.tags, []),
+      scope: row.scope,
+      kind: row.kind,
+      contentHash: row.content_hash,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      providerId: vectorRow?.provider_id ?? "",
+      dimensions: vectorRow?.dimensions ?? 0
+    };
+    if (vectorRow?.vector) {
+      entry.vector = decodeVector(vectorRow.vector);
+    }
+    return entry;
+  }
+  async syncFromSage(sage) {
+    this.assertOpen();
+    const memories = await sage.listActiveMemories({ limit: 5e3 });
+    let indexed = 0;
+    let skipped = 0;
+    let failed = 0;
+    const errors = [];
+    for (const memory of memories) {
+      try {
+        const existing = this.db.prepare("SELECT id FROM entries WHERE content_hash = ? LIMIT 1").get(_VectorMemoryStore.contentHash(memory.text));
+        if (existing) {
+          skipped++;
+          continue;
+        }
+        await this.remember({
+          text: memory.text,
+          summary: memory.summary ?? void 0,
+          metadata: { source: "sage", sageId: memory.id, ...memory.metadata ?? {} },
+          tags: memory.tags ?? [],
+          scope: "project",
+          kind: "note"
+        });
+        indexed++;
+      } catch (err) {
+        failed++;
+        errors.push({ memoryId: memory.id, message: errMsg(err) });
+      }
+    }
+    return { scanned: memories.length, indexed, skipped, failed, errors };
+  }
+};
+function fallbackHashingProvider(dimensions) {
+  return new HashingEmbeddingProvider({ dimensions });
+}
+function safeParseJson(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/tools.ts
+function createVectorMemoryTools(store) {
+  return [
+    vectorMemoryRememberTool(store),
+    vectorMemorySearchTool(store),
+    vectorMemoryStatsTool(store),
+    vectorMemoryForgetTool(store)
+  ];
+}
+function vectorMemoryRememberTool(store) {
+  return {
+    name: "vector_memory_remember",
+    category: "Memory",
+    description: "Persist a piece of knowledge into the local vector memory store. The text is embedded with the active embedding provider (transformers.js when available, otherwise the sage hashing provider). Returns the new entry id and whether an embedding was stored.",
+    usageHint: "Store text you want to find later by *meaning*, not just exact keywords. Embeddings happen locally \u2014 no project text leaves the machine.",
+    permission: "confirm",
+    mutating: true,
+    riskTier: "standard",
+    timeoutMs: 5e3,
+    capabilities: ["memory.write"],
+    icon: "settings",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", minLength: 1, description: "The text to embed and store." },
+        summary: { type: "string", description: "Optional short label." },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional tags for later filtering."
+        },
+        scope: {
+          type: "string",
+          enum: ["project", "user", "session"],
+          description: "Visibility scope. Defaults to `project`."
+        },
+        kind: {
+          type: "string",
+          enum: ["note", "fact", "summary", "snippet", "link"],
+          description: "Entry kind. Defaults to `note`."
+        },
+        metadata: {
+          type: "object",
+          additionalProperties: true,
+          description: "Free-form metadata persisted as JSON."
+        }
+      },
+      required: ["text"],
+      additionalProperties: false
+    },
+    execute: async (input) => {
+      const entry = await store.remember(input);
+      return { id: entry.id, hasVector: entry.vector !== void 0 };
+    }
+  };
+}
+function vectorMemorySearchTool(store) {
+  return {
+    name: "vector_memory_search",
+    category: "Memory",
+    description: "Semantic search over the vector memory store. Embeds the query with the active provider and returns the top-k entries ranked by cosine similarity. Returns an empty list when the embedding provider is unavailable \u2014 callers should fall back to lexical search.",
+    usageHint: "Use when you want results ranked by meaning. Pairs well with sage `memory_search` for keyword precision.",
+    permission: "auto",
+    mutating: false,
+    riskTier: "safe",
+    timeoutMs: 5e3,
+    capabilities: ["memory.read"],
+    icon: "search",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", minLength: 1, description: "The natural-language query." },
+        limit: { type: "number", minimum: 1, maximum: 100, description: "Max results (default 10)." },
+        threshold: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: "Minimum cosine similarity. Results below the floor are dropped."
+        },
+        scope: {
+          type: "string",
+          enum: ["project", "user", "session"],
+          description: "Restrict to a scope."
+        },
+        kind: {
+          type: "string",
+          enum: ["note", "fact", "summary", "snippet", "link"],
+          description: "Restrict to a kind."
+        }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    execute: async (input) => {
+      const hits = await store.search(input.query, {
+        limit: input.limit !== void 0 ? input.limit : void 0,
+        threshold: input.threshold !== void 0 ? input.threshold : void 0,
+        scope: input.scope,
+        kind: input.kind
+      });
+      return {
+        hits: hits.map((h) => ({
+          id: h.entry.id,
+          score: h.score,
+          text: h.entry.text,
+          summary: h.entry.summary ?? void 0,
+          tags: h.entry.tags
+        }))
+      };
+    }
+  };
+}
+function vectorMemoryStatsTool(store) {
+  return {
+    name: "vector_memory_stats",
+    category: "Memory",
+    description: "Return counts, providers, and dimensions for the local vector memory store.",
+    usageHint: "Cheap diagnostic \u2014 safe to call any time.",
+    permission: "auto",
+    mutating: false,
+    riskTier: "safe",
+    timeoutMs: 1e3,
+    capabilities: ["memory.read"],
+    icon: "search",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    execute: async () => store.stats()
+  };
+}
+function vectorMemoryForgetTool(store) {
+  return {
+    name: "vector_memory_forget",
+    category: "Memory",
+    description: "Remove an entry (and its vector) from the vector memory store.",
+    usageHint: "Hard delete \u2014 no soft-delete tombstone. Use `vector_memory_search` to find the id first if you only have text.",
+    permission: "confirm",
+    mutating: true,
+    riskTier: "standard",
+    timeoutMs: 1e3,
+    capabilities: ["memory.write"],
+    icon: "settings",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", minLength: 1, description: "Entry id returned by `vector_memory_remember`." }
+      },
+      required: ["id"],
+      additionalProperties: false
+    },
+    execute: async (input) => ({ removed: store.forget(input.id) })
+  };
+}
+export {
+  DEFAULT_VECTOR_DIMENSIONS,
+  DEFAULT_VECTOR_DTYPE,
+  DEFAULT_VECTOR_MODEL_ID,
+  TransformersEmbeddingProvider,
+  VECTOR_DIMENSIONS_KEY,
+  VECTOR_PROVIDER_KEY,
+  VECTOR_SCHEMA_VERSION,
+  VectorMemoryError,
+  VectorMemoryProviderUnavailableError,
+  VectorMemoryStore,
+  createVectorMemoryTools,
+  decodeVector,
+  encodeVector,
+  fallbackHashingProvider,
+  initVectorSchema
+};
+//# sourceMappingURL=index.js.map

package/dist/schema.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SQLite schema for the vector memory store.
+ *
+ * Two tables:
+ *  - `entries` — text + metadata, no embedding column
+ *  - `vectors` — (entry_id, provider_id) PK, raw float32 blob
+ *
+ * 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_PROVIDER_KEY = "active_provider_id";
+export declare const VECTOR_DIMENSIONS_KEY = "active_provider_dimensions";
+export declare function initVectorSchema(db: DatabaseSync): void;
+/** 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. */
+export declare function decodeVector(buf: Buffer | Uint8Array): Float32Array;
+//# sourceMappingURL=schema.d.ts.map

package/dist/store.d.ts

@@ -0,0 +1,43 @@
+import { HashingEmbeddingProvider } from '@wrongstack/sage';
+import type { SageSyncReport, VectorEntry, VectorEntryInput, VectorEntryWithVector, VectorKind, VectorMemoryStoreOptions, VectorScope, VectorSearchHit, VectorSearchOptions, VectorStoreStats } from './types.js';
+export declare class VectorMemoryStore {
+    private readonly db;
+    private readonly dbPath;
+    private readonly provider;
+    private closed;
+    constructor(opts: VectorMemoryStoreOptions);
+    get activeProviderId(): string;
+    private recordActiveProvider;
+    static contentHash(text: string): string;
+    remember(input: VectorEntryInput): Promise<VectorEntryWithVector>;
+    get(id: string): VectorEntryWithVector | undefined;
+    forget(id: string): boolean;
+    search(query: string, opts?: VectorSearchOptions): Promise<VectorSearchHit[]>;
+    list(opts?: {
+        limit?: number;
+        scope?: VectorScope;
+        kind?: VectorKind;
+    }): VectorEntry[];
+    reindexAll(): Promise<{
+        processed: number;
+        errors: number;
+    }>;
+    stats(): VectorStoreStats;
+    close(): void;
+    private assertOpen;
+    private rowToEntry;
+    syncFromSage(sage: SageSyncSource): Promise<SageSyncReport>;
+}
+export interface SageSyncSource {
+    listActiveMemories(opts: {
+        limit: number;
+    }): Promise<Array<{
+        id: string;
+        text: string;
+        summary?: string;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+    }>>;
+}
+export declare function fallbackHashingProvider(dimensions: number): HashingEmbeddingProvider;
+//# sourceMappingURL=store.d.ts.map

package/dist/tools.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Vector memory tools — agent-facing surface for the vector store.
+ *
+ * The tools mirror sage's tool patterns:
+ *  - reads (`vector_memory_search`, `vector_memory_stats`) → `permission: 'auto'`
+ *  - writes (`vector_memory_remember`, `vector_memory_forget`) → `permission: 'confirm'`
+ *
+ * All tools accept the store directly so hosts can wire them however they
+ * like — there's no implicit dependency on the sage runtime surface.
+ */
+import type { Tool } from '@wrongstack/core/types';
+import type { VectorMemoryStore } from './store.js';
+export declare function createVectorMemoryTools(store: VectorMemoryStore): Tool[];
+//# sourceMappingURL=tools.d.ts.map

package/dist/transformers-provider.d.ts

@@ -0,0 +1,67 @@
+/**
+ * TransformersEmbeddingProvider — wraps `@huggingface/transformers`'s
+ * feature-extraction pipeline as a sage `EmbeddingProvider`.
+ *
+ * The provider is lazy: nothing is imported until `embed()` is first called.
+ * If `@huggingface/transformers` is not installed (it's listed as an
+ * optionalDependency), `isAvailable()` returns false and `embed()` throws
+ * a descriptive `VectorMemoryProviderUnavailableError` so callers can
+ * fall back to `HashingEmbeddingProvider`.
+ *
+ * Default model: `Xenova/all-MiniLM-L6-v2` (384 dims, ~25MB quantized).
+ * On first use the model is fetched from the Hugging Face Hub and cached
+ * under `cacheDir` (default: `.wrongstack/vector-memory/models`).
+ */
+import type { EmbeddingProvider } from '@wrongstack/sage';
+export declare const DEFAULT_VECTOR_MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+export declare const DEFAULT_VECTOR_DIMENSIONS = 384;
+export declare const DEFAULT_VECTOR_DTYPE = "q8";
+export interface TransformersEmbeddingProviderOptions {
+    /** Hugging Face Hub model id (default `Xenova/all-MiniLM-L6-v2`). */
+    modelId?: string;
+    /** Local cache directory for downloaded model files. */
+    cacheDir?: string;
+    /** Inference dtype — `q8` is ~4x smaller and ~2x faster than `fp32`. */
+    dtype?: 'q8' | 'fp16' | 'fp32' | 'q4';
+    /** Device selector — Node builds default to `cpu` via onnxruntime-node. */
+    device?: 'cpu' | 'wasm' | 'webgpu';
+    /** Maximum texts per batch when calling the pipeline. */
+    batchSize?: number;
+    /** Maximum characters per input before the provider truncates. */
+    maxChars?: number;
+    /**
+     * Disable remote model downloads. Useful in offline / air-gapped runs
+     * — the provider will surface a clear error when the model isn't cached.
+     */
+    allowRemoteModels?: boolean;
+}
+export declare class TransformersEmbeddingProvider implements EmbeddingProvider {
+    readonly id: string;
+    readonly dimensions: number;
+    private readonly modelId;
+    private readonly cacheDir;
+    private readonly dtype;
+    private readonly device;
+    private readonly batchSize;
+    private readonly maxChars;
+    private readonly allowRemote;
+    private extractor;
+    private loadPromise;
+    constructor(opts?: TransformersEmbeddingProviderOptions);
+    /**
+     * Synchronous capability check. Returns false when the optional
+     * `@huggingface/transformers` dependency is not installed.
+     *
+     * NOTE: this probes via dynamic import and caches the result, but does
+     * NOT load the model itself — model loading is deferred to `embed()`.
+     */
+    isAvailable(): Promise<boolean>;
+    embed(texts: string[]): Promise<Float32Array[]>;
+    /** Truncate + normalize text before embedding. */
+    private prepare;
+    private tensorToVectors;
+    private getExtractor;
+    private loadExtractor;
+    private loadModule;
+}
+//# sourceMappingURL=transformers-provider.d.ts.map

package/dist/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Vector Memory — public type surface.
+ *
+ * The store persists entries (text + metadata) alongside their vector
+ * embeddings, keyed by provider id so a model change triggers re-indexing.
+ */
+import type { EmbeddingProvider } from '@wrongstack/sage';
+export type VectorScope = 'project' | 'user' | 'session';
+export type VectorKind = 'note' | 'fact' | 'summary' | 'snippet' | 'link';
+export interface VectorEntryInput {
+    text: string;
+    /** Optional short label — stored as-is, returned in search results. */
+    summary?: string | undefined;
+    /** Free-form metadata persisted as JSON. Use for source URLs, anchors, etc. */
+    metadata?: Record<string, unknown> | undefined;
+    tags?: string[] | undefined;
+    scope?: VectorScope | undefined;
+    kind?: VectorKind | undefined;
+    /** Embedding provider id override for this write. Defaults to the store's provider. */
+    providerId?: string | undefined;
+}
+export interface VectorEntry {
+    id: string;
+    text: string;
+    summary?: string | undefined;
+    metadata: Record<string, unknown>;
+    tags: string[];
+    scope: VectorScope;
+    kind: VectorKind;
+    /** Stable hash of the entry text — used to detect duplicate re-writes. */
+    contentHash: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface VectorEntryWithVector extends VectorEntry {
+    /** Provider id that produced the stored vector. */
+    providerId: string;
+    /** Vector dimensions (matches `EmbeddingProvider.dimensions`). */
+    dimensions: number;
+    /** Decoded vector; absent when no embedding has been computed yet. */
+    vector?: Float32Array | undefined;
+}
+export interface VectorSearchOptions {
+    limit?: number | undefined;
+    /** Minimum cosine similarity [0, 1]. Results below the floor are dropped. */
+    threshold?: number | undefined;
+    scope?: VectorScope | undefined;
+    kind?: VectorKind | undefined;
+    /** Provider id override for the query embedding. Defaults to the store's provider. */
+    providerId?: string | undefined;
+}
+export interface VectorSearchHit {
+    entry: VectorEntry;
+    /** Cosine similarity in [-1, 1]. The store clamps to [0, 1] before returning. */
+    score: number;
+    providerId: string;
+}
+export interface VectorStoreStats {
+    entries: number;
+    vectors: number;
+    providers: string[];
+    modelAvailable: boolean;
+    modelId: string;
+    dimensions: number;
+}
+/**
+ * The store accepts any `EmbeddingProvider` from `@wrongstack/sage`. In
+ * production the caller wires a `TransformersEmbeddingProvider`; tests and
+ * offline runs can substitute a `HashingEmbeddingProvider` or a fake.
+ */
+export interface VectorMemoryStoreOptions {
+    /** Embedding provider used for both write-side and query-side embedding. */
+    provider: EmbeddingProvider;
+    /** Absolute project root whose `.wrongstack/vector-memory/` directory owns the SQLite db. */
+    projectRoot: string;
+    /** Override the storage subdirectory (default `.wrongstack/vector-memory`). */
+    directory?: string;
+    /** Override the SQLite file name (default `vector-memory.db`). */
+    filename?: string;
+}
+/**
+ * Returned by `syncFromSage` — surfaces what was indexed, what was skipped,
+ * and any failures so the caller can log or retry.
+ */
+export interface SageSyncReport {
+    scanned: number;
+    indexed: number;
+    skipped: number;
+    failed: number;
+    errors: Array<{
+        memoryId: string;
+        message: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vector-codec.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Float32Array <-> SQLite BLOB codec.
+ *
+ * Mirrors the pattern used by `packages/tools/src/codebase-index/vector-search.ts`
+ * so that the on-disk byte layout is portable between the codebase-index
+ * and vector-memory stores. node:sqlite returns `Uint8Array` for BLOB columns,
+ * so we read through `DataView` regardless of the runtime type.
+ */
+export declare function encodeVector(vec: Float32Array): Buffer;
+export declare function decodeVector(buf: Buffer | Uint8Array): Float32Array;
+//# sourceMappingURL=vector-codec.d.ts.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@wrongstack/vector-memory",
+  "version": "0.308.0",
+  "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": {
+    "type": "git",
+    "url": "git+https://github.com/WrongStack/WrongStack.git",
+    "directory": "packages/vector-memory"
+  },
+  "homepage": "https://github.com/WrongStack/WrongStack#readme",
+  "bugs": "https://github.com/WrongStack/WrongStack/issues",
+  "author": "ECOSTACK TECHNOLOGY OÜ",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md"
+  ],
+  "dependencies": {
+    "@wrongstack/core": "0.308.0",
+    "@wrongstack/sage": "0.308.0"
+  },
+  "optionalDependencies": {
+    "@huggingface/transformers": "^4.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:integration": "WRONGSTACK_VECTOR_INTEGRATION=1 vitest run tests/integration.test.ts",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}