ruvector 0.2.29 → 0.2.31

package/bin/mcp-server.js

@@ -107,6 +107,18 @@ try {
   // IntelligenceEngine not available
 }
 
+// ADR-210 D0: shared embedding-provenance invariant — the SAME dist module
+// bin/cli.js uses (loadProvenance there), so the MCP server's writes to
+// .ruvector/intelligence.json enforce the same contract instead of bypassing
+// it. When dist is missing, enforcement degrades exactly like the CLI:
+// pre-ADR-210 behavior.
+let provenanceMod = null;
+try {
+  provenanceMod = require('../dist/core/embedding-provenance.js');
+} catch (e) {
+  provenanceMod = null;
+}
+
 // Intelligence class with full RuVector stack support
 class Intelligence {
   constructor() {
@@ -169,12 +181,126 @@ class Intelligence {
   load() {
     try {
       if (fs.existsSync(this.intelPath)) {
-        return JSON.parse(fs.readFileSync(this.intelPath, 'utf-8'));
+        const data = JSON.parse(fs.readFileSync(this.intelPath, 'utf-8'));
+        // Untrusted on-disk input (ADR-210 security pass): a corrupted or
+        // hand-edited store must not crash array/object consumers.
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+          if (!Array.isArray(data.memories)) data.memories = [];
+          return data;
+        }
       }
     } catch {}
     return { patterns: {}, memories: [], trajectories: [], errors: {}, agents: {}, edges: [] };
   }
 
+  // ==========================================================================
+  // ADR-210 D0: embedding-provenance invariant for intelligence.json writes.
+  // Same contract bin/cli.js enforces (this server previously bypassed it):
+  // mismatched vector writes are refused naming both sides, legacy stores
+  // (vectors without provenance) are read-only until `ruvector hooks reembed`,
+  // and degraded reads warn once per process.
+  // ==========================================================================
+
+  storedProvenance() {
+    const raw = this.data.embeddingProvenance || null;
+    if (!provenanceMod) return raw;
+    return provenanceMod.sanitizeProvenance(raw);
+  }
+
+  vectorMemoryCount() {
+    const mems = Array.isArray(this.data.memories) ? this.data.memories : [];
+    return mems.filter(m => m && Array.isArray(m.embedding) && m.embedding.length > 0).length;
+  }
+
+  /** Store predates ADR-210 (has vectors but no provenance record). */
+  isLegacyVectorStore() {
+    return !this.storedProvenance() && this.vectorMemoryCount() > 0;
+  }
+
+  /** Legacy default: hash, dimension inferred from the stored vectors. */
+  inferredLegacyProvenance() {
+    const mems = Array.isArray(this.data.memories) ? this.data.memories : [];
+    const first = mems.find(m => m && Array.isArray(m.embedding) && m.embedding.length > 0);
+    const dim = first ? first.embedding.length : 256;
+    if (provenanceMod) return provenanceMod.legacyHashProvenance(dim);
+    return { embedderKind: 'hash', modelId: null, dimension: dim, normalize: false, prefixPolicy: 'none' };
+  }
+
+  /** Provenance of the embedder that just produced `embedding`. */
+  activeWriteProvenance(embedding) {
+    if (this.engine && typeof this.engine.getActiveProvenance === 'function') {
+      try { return this.engine.getActiveProvenance(); } catch {}
+    }
+    return { embedderKind: 'hash', modelId: null, dimension: embedding.length, normalize: true, prefixPolicy: 'none' };
+  }
+
+  /**
+   * Gate a vector write (throws on refusal). Stamps provenance on the first
+   * write to a fresh store; refuses mismatched writes naming both sides;
+   * legacy stores are read-only until re-embedded.
+   */
+  checkVectorWrite(active) {
+    if (!provenanceMod || !active) return; // enforcement needs the dist module
+    if (this.isLegacyVectorStore()) {
+      const legacy = this.inferredLegacyProvenance();
+      const err = new Error(
+        `Vector store ${this.intelPath} predates embedding provenance (ADR-210) and is read-only for vector writes. ` +
+        `Stored vectors are treated as ${provenanceMod.describeProvenance(legacy)}; the active embedder is ` +
+        `${provenanceMod.describeProvenance(active)}. Run 'ruvector hooks reembed' to re-embed and unlock it.`
+      );
+      err.code = 'ERR_LEGACY_STORE_READONLY';
+      throw err;
+    }
+    const stored = this.storedProvenance();
+    if (!stored) {
+      this.data.embeddingProvenance = active;
+      return;
+    }
+    provenanceMod.assertProvenanceMatch(stored, active, this.intelPath);
+  }
+
+  /**
+   * Non-throwing write gate honoring RUVECTOR_REEMBED (D5): refuse (default)
+   * rethrows; warn skips the write with one stderr warning per process.
+   */
+  guardVectorWrite(active) {
+    try {
+      this.checkVectorWrite(active);
+      return { ok: true };
+    } catch (e) {
+      const policy = provenanceMod ? provenanceMod.resolveReembedPolicy() : 'refuse';
+      if (policy === 'warn') {
+        if (!Intelligence._reembedWarned) {
+          Intelligence._reembedWarned = true;
+          console.error(`ruvector: ${e.message} (RUVECTOR_REEMBED=warn: store stays read-only, write skipped)`);
+        }
+        return { ok: false, skipped: true, error: e.message };
+      }
+      if (policy === 'auto') e.message += ` (RUVECTOR_REEMBED=auto: run 'ruvector hooks reembed' — in-place re-embedding needs the CLI)`;
+      throw e;
+    }
+  }
+
+  /**
+   * ADR-210: reads stay allowed on legacy/mismatched stores, but similarity
+   * against differently-embedded vectors is meaningless — say so once.
+   */
+  warnRecallProvenance(active) {
+    if (!provenanceMod || !active || Intelligence._recallWarned) return;
+    let stored = this.storedProvenance();
+    if (!stored && this.isLegacyVectorStore()) stored = this.inferredLegacyProvenance();
+    if (!stored) return;
+    const mismatches = provenanceMod.compareProvenance(stored, active);
+    if (mismatches.length > 0) {
+      Intelligence._recallWarned = true;
+      console.error(
+        `ruvector: recall quality degraded — stored vectors are ${provenanceMod.describeProvenance(stored)} ` +
+        `but the query was embedded as ${provenanceMod.describeProvenance(active)} (differs on: ${mismatches.join(', ')}). ` +
+        `Run 'ruvector hooks reembed' to fix.`
+      );
+    }
+  }
+
   save() {
     const dir = path.dirname(this.intelPath);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -207,6 +333,8 @@ class Intelligence {
           sonaEnabled: engineStats.sonaEnabled,
           attentionEnabled: engineStats.attentionEnabled,
           embeddingDim: engineStats.memoryDimensions,
+          // ADR-210 D1: which embedder actually serves embeds right now
+          embedderKind: engineStats.embedderKind,
           totalMemories: engineStats.totalMemories,
           totalEpisodes: engineStats.totalEpisodes,
           trajectoriesRecorded: engineStats.trajectoriesRecorded,
@@ -248,19 +376,31 @@ class Intelligence {
   async remember(content, type = 'general') {
     // Use engine if available (VectorDB storage)
     if (this.engine) {
+      let entry = null;
       try {
-        const entry = await this.engine.remember(content, type);
+        entry = await this.engine.remember(content, type);
+      } catch {}
+      if (entry) {
+        // ADR-210 D0: validate provenance BEFORE persisting. Refusals
+        // propagate as errors (the tool handler reports them) — no silent
+        // fallback into a mixed store.
+        const guard = this.guardVectorWrite(this.activeWriteProvenance(entry.embedding));
+        if (!guard.ok) return { stored: false, skipped: true, reason: guard.error };
         // Also store in legacy format
-        this.data.memories = this.data.memories || [];
+        this.data.memories = Array.isArray(this.data.memories) ? this.data.memories : [];
         this.data.memories.push({ content, type, created: new Date().toISOString(), embedding: entry.embedding });
         this.save();
         return { stored: true, total: this.data.memories.length, engineStored: true };
-      } catch {}
+      }
     }
 
     // Fallback
-    this.data.memories = this.data.memories || [];
-    this.data.memories.push({ content, type, created: new Date().toISOString(), embedding: this.embed(content) });
+    const embedding = this.embed(content);
+    // ADR-210 D0: same gate on the fallback hash path.
+    const guard = this.guardVectorWrite({ embedderKind: 'hash', modelId: null, dimension: embedding.length, normalize: true, prefixPolicy: 'none' });
+    if (!guard.ok) return { stored: false, skipped: true, reason: guard.error };
+    this.data.memories = Array.isArray(this.data.memories) ? this.data.memories : [];
+    this.data.memories.push({ content, type, created: new Date().toISOString(), embedding });
     this.save();
     return { stored: true, total: this.data.memories.length };
   }
@@ -270,6 +410,11 @@ class Intelligence {
     if (this.engine) {
       try {
         const results = await this.engine.recall(query, topK);
+        // ADR-210: after recall the engine's lazy init has settled, so the
+        // active provenance reflects the embedder that served the query.
+        if (typeof this.engine.getActiveProvenance === 'function') {
+          this.warnRecallProvenance(this.engine.getActiveProvenance());
+        }
         return results.map(r => ({
           content: r.content,
           type: r.type,
@@ -282,10 +427,12 @@ class Intelligence {
 
     // Fallback: brute-force
     const queryEmbed = this.embed(query);
-    const scored = (this.data.memories || []).map((m, i) => ({
+    this.warnRecallProvenance({ embedderKind: 'hash', modelId: null, dimension: queryEmbed.length, normalize: true, prefixPolicy: 'none' });
+    const mems = Array.isArray(this.data.memories) ? this.data.memories : [];
+    const scored = mems.map((m, i) => ({
       ...m,
       index: i,
-      score: this.similarity(queryEmbed, m.embedding)
+      score: this.similarity(queryEmbed, m && m.embedding)
     }));
     return scored.sort((a, b) => b.score - a.score).slice(0, topK);
   }
@@ -363,7 +510,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.2.29',
+    version: '0.2.30',
   },
   {
     capabilities: {
@@ -1586,12 +1733,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'hooks_remember': {
+        // ADR-210 D0: provenance refusals throw and surface via the catch-all
+        // as isError; RUVECTOR_REEMBED=warn skips return { stored: false }.
         const result = await intel.remember(args.content, args.type || 'general');
         return {
           content: [{
             type: 'text',
             text: JSON.stringify({
-              success: true,
+              success: result.stored !== false,
               ...result
             }, null, 2)
           }]
@@ -1818,6 +1967,32 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
           }
           if (data.memories && Array.isArray(data.memories)) {
+            // ADR-210 D0: imported memories carrying vectors are a vector
+            // write — enforce the store's embedding provenance (this was a
+            // bypass before wave 2).
+            const withVectors = data.memories.filter(m => m && Array.isArray(m.embedding) && m.embedding.length > 0);
+            if (withVectors.length > 0 && provenanceMod) {
+              if (intel.isLegacyVectorStore()) {
+                const err = new Error(
+                  `Vector store ${intel.intelPath} predates embedding provenance (ADR-210) and is read-only for vector writes. ` +
+                  `Run 'ruvector hooks reembed' before importing vector memories.`
+                );
+                err.code = 'ERR_LEGACY_STORE_READONLY';
+                throw err;
+              }
+              const stored = intel.storedProvenance();
+              if (stored) {
+                const bad = withVectors.find(m => m.embedding.length !== stored.dimension);
+                if (bad) {
+                  throw new Error(
+                    `Import refused (ADR-210): ${intel.intelPath} records embedding provenance ` +
+                    `${provenanceMod.describeProvenance(stored)}, but imported memories contain ` +
+                    `${bad.embedding.length}-dimensional vectors with undeclared provenance. ` +
+                    `Mixed stores are never created — re-embed the data or the store.`
+                  );
+                }
+              }
+            }
             if (merge) {
               intel.data.memories = [...(intel.data.memories || []), ...data.memories];
             } else {
@@ -1848,7 +2023,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             content: [{
               type: 'text',
               text: JSON.stringify({ success: false, error: e.message }, null, 2)
-            }]
+            }],
+            isError: true
           };
         }
       }
@@ -3837,18 +4013,23 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
 
 // Start server
 async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('RuVector MCP server running on stdio');
-
   // Exit cleanly when the parent process closes the stdio pipe or sends a
   // termination signal. Without these handlers, the MCP server can survive
   // the parent's death (e.g. when the client is killed with SIGKILL) and
   // accumulate as an orphaned process under PPID=1, consuming RSS for the
-  // lifetime of the user session.
-  process.stdin.on('end', () => process.exit(0));
+  // lifetime of the user session. Registered BEFORE the (async) transport
+  // connect: a signal arriving during startup previously hit the default
+  // handler and died with a non-zero code — a race that made the
+  // sigterm-cleanup suite flaky (SIGTERM and SIGINT failed alternately on
+  // CI depending on which spawn won the 2s ready-wait).
   process.on('SIGINT', () => process.exit(0));
   process.on('SIGTERM', () => process.exit(0));
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('RuVector MCP server running on stdio');
+
+  process.stdin.on('end', () => process.exit(0));
 }
 
 main().catch(console.error);

package/dist/core/embedding-provenance.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Embedding provenance — ADR-210 D0 cross-cutting invariant.
+ *
+ * Every persisted vector store written through the embedding path records
+ * `{ embedderKind, modelId, dimension, normalize, prefixPolicy }`. Inserts
+ * whose provenance does not match the store's recorded provenance are
+ * REFUSED (clear error naming both sides), never coerced. Stores that
+ * predate provenance metadata are treated as legacy hash stores and open
+ * read-only for vector writes until re-embedded (`ruvector hooks reembed`).
+ *
+ * This module is the single source of truth for:
+ *   - the provenance record type + compare/refuse logic (D0),
+ *   - legacy-default derivation for pre-ADR-210 stores (D0),
+ *   - per-model query/passage prefix policies (D4),
+ *   - rollout flag resolution: RUVECTOR_EMBEDDER / RUVECTOR_ONNX /
+ *     RUVECTOR_REEMBED (D5),
+ *   - the once-per-process loud hash-fallback warning (D1).
+ */
+export type PrefixPolicy = 'none' | 'required' | 'query-recommended';
+export type EmbedTextKind = 'query' | 'passage';
+/** Embedder identity classes. `modelId` carries the exact model. */
+export type EmbedderKind = 'onnx-minilm' | 'onnx' | 'hash';
+export interface EmbeddingProvenance {
+    /** Embedder family that produced the vectors. */
+    embedderKind: EmbedderKind | string;
+    /** Exact model id (e.g. 'all-MiniLM-L6-v2'); null for the hash embedder. */
+    modelId: string | null;
+    /** Vector dimension. */
+    dimension: number;
+    /** Whether vectors were L2-normalized at embed time. */
+    normalize: boolean;
+    /** Prefix convention the texts were embedded under (D4). */
+    prefixPolicy: PrefixPolicy;
+}
+export type EmbedderSelection = 'auto' | 'minilm' | 'hash';
+export type ReembedPolicy = 'refuse' | 'warn' | 'auto';
+export interface ModelPrefixSpec {
+    prefixPolicy: PrefixPolicy;
+    queryPrefix: string;
+    passagePrefix: string;
+}
+/** BGE en v1.5 documented query instruction (short query → long passage). */
+export declare const BGE_QUERY_INSTRUCTION = "Represent this sentence for searching relevant passages: ";
+/**
+ * Prefix conventions per model card:
+ * - all-MiniLM-L6-v2 / L12: general semantic search, NO prefixes.
+ * - e5-small-v2: REQUIRES 'query: ' / 'passage: ' (quality degrades without).
+ * - bge-small/base-en-v1.5: query instruction recommended for retrieval;
+ *   passages need no instruction.
+ * - gte-small: no prefixes documented.
+ */
+export declare const MODEL_PREFIXES: Record<string, ModelPrefixSpec>;
+/**
+ * Prefix spec for a model; unknown models get the no-prefix policy.
+ * Own-property lookup only: a hostile model id like '__proto__' or
+ * 'constructor' must resolve to NO_PREFIX, not to a prototype member
+ * (ADR-210 security pass).
+ */
+export declare function getModelPrefixSpec(modelId: string | null | undefined): ModelPrefixSpec;
+/**
+ * Pure prefix application (D4): the exact text handed to the tokenizer for a
+ * query/passage embed of `text` under `modelId`'s registered policy.
+ * MiniLM applies NO prefix on either entry point (acceptance gates 6–7).
+ */
+export declare function prefixText(modelId: string | null | undefined, kind: EmbedTextKind, text: string): string;
+/** Embedder family for an ONNX model id. */
+export declare function embedderKindForModel(modelId: string | null | undefined): EmbedderKind;
+/**
+ * Legacy default for stores that predate provenance metadata: hash-embedded,
+ * un-normalized as far as we can prove, no prefixes. Such stores open
+ * READ-ONLY for vector writes until re-embedded.
+ */
+export declare function legacyHashProvenance(dimension?: number): EmbeddingProvenance;
+/** Human-readable one-liner for error messages. */
+export declare function describeProvenance(p: EmbeddingProvenance): string;
+/** Field names on which two provenance records disagree (empty = match). */
+export declare function compareProvenance(a: EmbeddingProvenance, b: EmbeddingProvenance): string[];
+/** Upper bound accepted for a provenance dimension read from disk. */
+export declare const MAX_PROVENANCE_DIMENSION = 65536;
+/**
+ * Sanitize a provenance record read from DISK (a `.meta.json` sidecar or
+ * `intelligence.json`). On-disk JSON is untrusted input: a malformed or
+ * adversarial record must never crash the caller. Anything that is not a
+ * plausibly-valid record is treated as ABSENT (returns null), which callers
+ * already handle as the no-provenance / legacy path — conservative for a
+ * corrupted stamp (the store degrades to read-only for vector writes rather
+ * than accepting writes under a fabricated identity).
+ */
+export declare function sanitizeProvenance(value: unknown): EmbeddingProvenance | null;
+/** Thrown when an insert's provenance does not match the store's (D0). */
+export declare class ProvenanceMismatchError extends Error {
+    code: string;
+    store: EmbeddingProvenance;
+    active: EmbeddingProvenance;
+    mismatches: string[];
+    constructor(store: EmbeddingProvenance, active: EmbeddingProvenance, mismatches: string[], storeName: string);
+}
+/** Refuse mismatched inserts with an error naming both sides (D0). */
+export declare function assertProvenanceMatch(store: EmbeddingProvenance, active: EmbeddingProvenance, storeName?: string): void;
+/**
+ * Resolve RUVECTOR_EMBEDDER / RUVECTOR_ONNX.
+ * Precedence: RUVECTOR_EMBEDDER wins when both are set; RUVECTOR_ONNX=0 is
+ * shorthand for `hash`, =1 for `minilm`. Unrecognized values fall back to
+ * 'auto' (MiniLM when loadable, loud hash fallback otherwise).
+ */
+export declare function resolveEmbedderSelection(env?: NodeJS.ProcessEnv): EmbedderSelection;
+/**
+ * Resolve RUVECTOR_REEMBED: what happens when opening a store whose
+ * provenance mismatches the active embedder.
+ *   refuse (default) — error;
+ *   warn             — open read-only with a single warning;
+ *   auto             — re-embed in place when source text exists, refuse otherwise.
+ */
+export declare function resolveReembedPolicy(env?: NodeJS.ProcessEnv): ReembedPolicy;
+/**
+ * Emit exactly ONE stderr warning per process the first time the hash
+ * fallback serves an embed that the ONNX embedder was supposed to handle
+ * (acceptance gate 2). Returns true when the warning was emitted by this call.
+ */
+export declare function warnHashFallbackOnce(reason?: string): boolean;
+/** Whether the once-per-process fallback warning has fired. */
+export declare function hashFallbackWarned(): boolean;
+/** Test hook: reset the once-per-process warning latch. */
+export declare function resetHashFallbackWarningForTests(): void;
+declare const _default: {
+    MODEL_PREFIXES: Record<string, ModelPrefixSpec>;
+    BGE_QUERY_INSTRUCTION: string;
+    getModelPrefixSpec: typeof getModelPrefixSpec;
+    prefixText: typeof prefixText;
+    embedderKindForModel: typeof embedderKindForModel;
+    legacyHashProvenance: typeof legacyHashProvenance;
+    describeProvenance: typeof describeProvenance;
+    compareProvenance: typeof compareProvenance;
+    sanitizeProvenance: typeof sanitizeProvenance;
+    MAX_PROVENANCE_DIMENSION: number;
+    ProvenanceMismatchError: typeof ProvenanceMismatchError;
+    assertProvenanceMatch: typeof assertProvenanceMatch;
+    resolveEmbedderSelection: typeof resolveEmbedderSelection;
+    resolveReembedPolicy: typeof resolveReembedPolicy;
+    warnHashFallbackOnce: typeof warnHashFallbackOnce;
+    hashFallbackWarned: typeof hashFallbackWarned;
+    resetHashFallbackWarningForTests: typeof resetHashFallbackWarningForTests;
+};
+export default _default;
+//# sourceMappingURL=embedding-provenance.d.ts.map

package/dist/core/embedding-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-provenance.d.ts","sourceRoot":"","sources":["../../src/core/embedding-provenance.ts"],"names":[],"mappings":"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"}