prism-mcp-server 7.8.4 → 7.8.7

package/README.md

@@ -691,9 +691,9 @@ The Generator strips the `console.log`, resubmits, and the next `EVALUATE` retur
 
 ## 🆕 What's New
 
-> **Current release: v7.8.2 — Cognitive Architecture**
+> **Current release: v7.8.7 — Cognitive Architecture**
 
-- 🧠 **v7.8.0 — Cognitive Architecture:** The biggest leap forward yet. Moved beyond flat vector search into a true cognitive architecture inspired by human brain mechanics. Episodic-to-Semantic memory consolidation (Hebbian learning), ACT-R Spreading Activation with multi-hop causal reasoning, Uncertainty-Aware Rejection Gate (your agent can say "I don't know"), and Dynamic Fast Weight Decay (semantic memories outlive episodic chatter by 2×). **Your agents don't just remember; they learn.** → [Cognitive Architecture](#-cognitive-architecture-v78)
+- 🧠 **v7.8.x — Cognitive Architecture:** The biggest leap forward yet. Moved beyond flat vector search into a true cognitive architecture inspired by human brain mechanics. Episodic-to-Semantic memory consolidation (Hebbian learning), ACT-R Spreading Activation with multi-hop causal reasoning, Uncertainty-Aware Rejection Gate (your agent can say "I don't know"), and Dynamic Fast Weight Decay (semantic memories outlive episodic chatter by 2×). Validated by **LoCoMo-Plus benchmark** (arXiv 2602.10715) with Precision@K and MRR metrics. **Your agents don't just remember; they learn.** → [Cognitive Architecture](#-cognitive-architecture-v78)
 - 🌐 **v7.7.0 — Cloud-Native SSE Transport:** Full unauthenticated and authenticated Server-Sent Events MCP support for seamless network deployments.
 - 🩺 **v7.5.0 — Intent Health Dashboard + Security Hardening:** Real-time 0–100 project health scoring (staleness × TODO load × decisions). 10 XSS injection vectors patched. Algorithm hardened with NaN guards and score ceiling.
 - ⚔️ **v7.4.0 — Adversarial Evaluation:** Split-brain anti-sycophancy pipeline. Generator and evaluator in isolated roles with evidence-bound findings.
@@ -968,6 +968,7 @@ Prism is a **stdio-based MCP server** that manages persistent agent memory. Here
 │  │  • ACT-R Spreading Activation (multi-hop)         │  │
 │  │  • Episodic → Semantic Consolidation (Hebbian)    │  │
 │  │  • Uncertainty-Aware Rejection Gate               │  │
+│  │  • LoCoMo-Plus Benchmark Validation               │  │
 │  │  • Dynamic Fast Weight Decay (dual-rate)          │  │
 │  │  • HDC Cognitive Routing (XOR binding)            │  │
 │  └──────┬─────────────────────────────────────────────┘  │
@@ -1056,16 +1057,18 @@ Prism has evolved from smart session logging into a **cognitive memory architect
 | **v7.8** | Multi-Hop Causal Reasoning — spreading activation traverses `caused_by`/`led_to` edges with damped fan effect (`1/ln(fan+e)`) and lateral inhibition | ACT-R spreading activation (Anderson), Collins & Loftus (1975) | ✅ Shipped |
 | **v7.8** | Uncertainty-Aware Rejection Gate — dual-signal (similarity floor + gap distance) safety layer prevents hallucination from low-confidence retrievals | Metacognition research, uncertainty quantification | ✅ Shipped |
 | **v7.8** | Dynamic Fast Weight Decay — `is_rollup` semantic nodes decay 50% slower (`ageModifier = 0.5`) than episodic entries, creating Long-Term Context anchors | ACT-R base-level activation with differential decay rates | ✅ Shipped |
+| **v7.8** | LoCoMo Benchmark Harness — deterministic integration suite (`tests/benchmarks/locomo.ts`, 20 assertions) benchmarking multi-hop compaction structures via `MockLLM` | Long-Context Memory evaluation (cognitive benchmarking) | ✅ Shipped |
+| **v7.8** | LoCoMo-Plus Benchmark — 16-assertion suite (`tests/benchmarks/locomo-plus.ts`) adapted from arXiv 2602.10715 validating cue–trigger semantic disconnect bridging via graph traversal and Hebbian consolidation; reports Precision@1/3/5/10 and MRR | LoCoMo-Plus (Li et al., ARR 2026), cue–trigger disconnect research | ✅ Shipped |
 | **v7.x** | Affect-Tagged Memory — sentiment shapes what gets recalled | Affect-modulated retrieval (neuroscience) | 🔭 Horizon |
 | **v8+** | Zero-Search Retrieval — no index, no ANN, just ask the vector | Holographic Reduced Representations | 🔭 Horizon |
 
-> Informed by Anderson's ACT-R (Adaptive Control of Thought—Rational), Collins & Loftus spreading activation networks (1975), Kanerva's SDM (1988), Hebb's learning rule, and LeCun's "Why AI Systems Don't Learn" (Dupoux, LeCun, Malik).
+> Informed by Anderson's ACT-R (Adaptive Control of Thought—Rational), Collins & Loftus spreading activation networks (1975), Kanerva's SDM (1988), Hebb's learning rule, Li et al. LoCoMo-Plus (ARR 2026), and LeCun's "Why AI Systems Don't Learn" (Dupoux, LeCun, Malik).
 
 ---
 
 ## 📦 Milestones & Roadmap
 
-> **Current: v7.8.2** — Cognitive Architecture ([CHANGELOG](CHANGELOG.md))
+> **Current: v7.8.7** — Cognitive Architecture ([CHANGELOG](CHANGELOG.md))
 
 | Release | Headline |
 |---------|----------|

package/dist/dashboard/server.js

@@ -445,6 +445,7 @@ return false;}
                             let cursorId = undefined;
                             let iterations = 0;
                             const MAX_ITERATIONS = 100; // safety cap: 100 × 50 = 5000 entries max
+                            let lastBackfillError = undefined;
                             while (hasMore && iterations < MAX_ITERATIONS) {
                                 iterations++;
                                 const result = await backfillEmbeddingsHandler({ dry_run: false, limit: 50, _cursor_id: cursorId });
@@ -452,6 +453,8 @@ return false;}
                                 if (bStats) {
                                     repairedCount += bStats.repaired;
                                     failedCount += bStats.failed;
+                                    if (bStats.error)
+                                        lastBackfillError = bStats.error;
                                     if (bStats.last_id)
                                         cursorId = bStats.last_id;
                                     else
@@ -464,8 +467,10 @@ return false;}
                                 }
                             }
                             cleanupMessages.push(`Repaired ${repairedCount} embeddings`);
-                            if (failedCount > 0)
-                                cleanupMessages.push(`Failed to repair ${failedCount} embeddings`);
+                            if (failedCount > 0) {
+                                const errMsg = lastBackfillError ? ` (${lastBackfillError})` : '';
+                                cleanupMessages.push(`Failed to repair ${failedCount} embeddings${errMsg}`);
+                            }
                         }
                         catch (err) {
                             console.error("[Dashboard] Failed to backfill embeddings:", err);

package/dist/storage/supabase.js

@@ -1442,8 +1442,43 @@ export class SupabaseStorage {
     }
     // ─── v7.5: Semantic Consolidation ────────────────────────────────
     async upsertSemanticKnowledge(data) {
-        // For now we just implement graceful degradation/no-op on Supabase until the SQL is deployed.
-        debugLog(`[SupabaseStorage] upsertSemanticKnowledge is not fully implemented in Supabase yet. Skipping for ${data.concept}.`);
-        return crypto.randomUUID();
+        const userId = data.userId || PRISM_USER_ID;
+        // Check if concept already exists
+        const existing = await supabaseGet("semantic_knowledge", {
+            project: `eq.${data.project}`,
+            concept: `eq.${data.concept}`,
+            select: "id,instances,confidence",
+            limit: "1"
+        });
+        const rows = Array.isArray(existing) ? existing : [];
+        if (rows.length > 0) {
+            const row = rows[0];
+            const newConfidence = Math.min(1.0, (row.confidence || 0) + 0.1);
+            const newInstances = (row.instances || 0) + 1;
+            await supabasePatch("semantic_knowledge", {
+                instances: newInstances,
+                confidence: newConfidence,
+                updated_at: new Date().toISOString()
+            }, {
+                id: `eq.${row.id}`
+            });
+            return row.id;
+        }
+        else {
+            const id = crypto.randomUUID();
+            await supabasePost("semantic_knowledge", {
+                id,
+                project: data.project,
+                user_id: userId,
+                concept: data.concept,
+                description: data.description,
+                confidence: 0.5,
+                instances: 1,
+                related_entities: data.related_entities ? JSON.stringify(data.related_entities) : "[]",
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString()
+            });
+            return id;
+        }
     }
 }

package/dist/tools/hygieneHandlers.js

@@ -98,46 +98,74 @@ export async function backfillEmbeddingsHandler(args) {
             isError: false,
         };
     }
-    // Generate embeddings for each entry
     let repaired = 0;
     let failed = 0;
-    for (const entry of entries) {
+    let lastError = undefined;
+    const validEntries = entries.map(e => {
+        const entry = e;
+        const textToEmbed = [
+            entry.summary || "",
+            ...(entry.decisions || []),
+        ].filter(Boolean).join(" | ");
+        return { entry, textToEmbed };
+    }).filter(x => {
+        if (!x.textToEmbed.trim()) {
+            debugLog(`[backfill] Skipping entry ${x.entry.id}: no text content`);
+            failed++;
+            return false;
+        }
+        return true;
+    });
+    if (validEntries.length > 0) {
+        const provider = getLLMProvider();
         try {
-            const e = entry;
-            const textToEmbed = [
-                e.summary || "",
-                ...(e.decisions || []),
-            ].filter(Boolean).join(" | ");
-            if (!textToEmbed.trim()) {
-                debugLog(`[backfill] Skipping entry ${e.id}: no text content`);
-                failed++;
-                continue;
+            let embeddings;
+            if (provider.generateEmbeddings) {
+                // Use batch API
+                embeddings = await provider.generateEmbeddings(validEntries.map(x => x.textToEmbed));
             }
-            const embedding = await getLLMProvider().generateEmbedding(textToEmbed);
-            // Build atomic patch — float32 + TurboQuant in ONE DB update
-            const patchData = {
-                embedding: JSON.stringify(embedding),
-            };
-            // TurboQuant: compress alongside repair (non-fatal)
-            try {
-                const { getDefaultCompressor, serialize } = await import("../utils/turboquant.js");
-                const compressor = getDefaultCompressor();
-                const compressed = compressor.compress(embedding);
-                const buf = serialize(compressed);
-                patchData.embedding_compressed = buf.toString("base64");
-                patchData.embedding_format = `turbo${compressor.bits}`;
-                patchData.embedding_turbo_radius = compressed.radius;
+            else {
+                // Fallback to sequential if batching is not supported by the adapter
+                embeddings = [];
+                for (const { textToEmbed } of validEntries) {
+                    embeddings.push(await provider.generateEmbedding(textToEmbed));
+                }
             }
-            catch (turboErr) {
-                debugLog(`[backfill] TurboQuant compression failed for ${e.id} (non-fatal): ${turboErr.message}`);
+            for (let i = 0; i < validEntries.length; i++) {
+                const { entry } = validEntries[i];
+                const embedding = embeddings[i];
+                try {
+                    const patchData = {
+                        embedding: JSON.stringify(embedding),
+                    };
+                    try {
+                        const { getDefaultCompressor, serialize } = await import("../utils/turboquant.js");
+                        const compressor = getDefaultCompressor();
+                        const compressed = compressor.compress(embedding);
+                        const buf = serialize(compressed);
+                        patchData.embedding_compressed = buf.toString("base64");
+                        patchData.embedding_format = `turbo${compressor.bits}`;
+                        patchData.embedding_turbo_radius = compressed.radius;
+                    }
+                    catch (turboErr) {
+                        debugLog(`[backfill] TurboQuant compression failed for ${entry.id} (non-fatal): ${turboErr.message}`);
+                    }
+                    await storage.patchLedger(entry.id, patchData);
+                    repaired++;
+                    debugLog(`[backfill] ✅ Repaired ${entry.id} (${entry.project})`);
+                }
+                catch (entryErr) {
+                    failed++;
+                    lastError = entryErr instanceof Error ? entryErr.message : String(entryErr);
+                    console.error(`[backfill] ❌ Failed ${entry.id}: ${lastError}`);
+                }
             }
-            await storage.patchLedger(e.id, patchData);
-            repaired++;
-            debugLog(`[backfill] ✅ Repaired ${e.id} (${e.project})`);
         }
         catch (err) {
-            failed++;
-            console.error(`[backfill] ❌ Failed ${entry.id}: ${err instanceof Error ? err.message : err}`);
+            // Embedding API call itself failed — entire batch is lost.
+            failed += validEntries.length;
+            lastError = err instanceof Error ? err.message : String(err);
+            console.error(`[backfill] ❌ Embedding API failed for batch of ${validEntries.length}: ${lastError}`);
         }
     }
     return {
@@ -152,7 +180,7 @@ export async function backfillEmbeddingsHandler(args) {
                         : `All entries now have embeddings for semantic search.`),
             }],
         isError: false,
-        _stats: { repaired, failed, last_id: entries[entries.length - 1]?.id },
+        _stats: { repaired, failed, error: lastError, last_id: entries[entries.length - 1]?.id },
     };
 }
 export async function sessionBackfillLinksHandler(args) {

package/dist/utils/llm/adapters/traced.js

@@ -46,6 +46,10 @@ import { getTracer } from "../../telemetry.js";
 export class TracingLLMProvider {
     inner;
     providerName;
+    /**
+     * Optional batch embeddings generation support.
+     */
+    generateEmbeddings;
     /**
      * The optional VLM method is declared here as a typed property so TypeScript
      * knows about it. It is assigned (or left undefined) in the constructor body
@@ -62,6 +66,37 @@ export class TracingLLMProvider {
     constructor(inner, providerName) {
         this.inner = inner;
         this.providerName = providerName;
+        // ── Batch Embeddings: conditional own-property assignment ───────────────
+        if (inner.generateEmbeddings) {
+            const innerEmbeds = inner.generateEmbeddings.bind(inner);
+            const providerName = this.providerName;
+            this.generateEmbeddings = async (texts) => {
+                const span = getTracer().startSpan("llm.generate_embeddings_batch", {
+                    attributes: {
+                        "llm.provider": providerName,
+                        "llm.batch_size": texts.length,
+                    },
+                });
+                return context.with(trace.setSpan(context.active(), span), async () => {
+                    try {
+                        const result = await innerEmbeds(texts);
+                        span.setStatus({ code: SpanStatusCode.OK });
+                        return result;
+                    }
+                    catch (err) {
+                        span.recordException(err instanceof Error ? err : new Error(String(err)));
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: err instanceof Error ? err.message : String(err),
+                        });
+                        throw err;
+                    }
+                    finally {
+                        span.end();
+                    }
+                });
+            };
+        }
         // ── VLM method: conditional own-property assignment ──────────────────
         // REVIEWER NOTE: TypeScript class methods always appear on the prototype,
         // which means `if (llm.generateImageDescription)` would always be truthy

package/dist/utils/llm/adapters/voyage.js

@@ -78,53 +78,78 @@ export class VoyageAdapter {
             "Set text_provider to 'anthropic', 'openai', or 'gemini' in the dashboard.");
     }
     // ─── Embedding Generation ────────────────────────────────────────────────
-    async generateEmbedding(text) {
-        if (!text || !text.trim()) {
-            throw new Error("[VoyageAdapter] generateEmbedding called with empty text");
-        }
+    async generateEmbeddings(texts) {
+        if (!texts || texts.length === 0)
+            return [];
         // Truncate to character limit (consistent with other adapters)
-        const truncated = text.length > MAX_EMBEDDING_CHARS
+        const truncatedTexts = texts.map(text => text.length > MAX_EMBEDDING_CHARS
             ? text.slice(0, MAX_EMBEDDING_CHARS).replace(/\s+\S*$/, "")
-            : text;
+            : text);
         const model = getSettingSync("voyage_model", DEFAULT_MODEL);
-        debugLog(`[VoyageAdapter] generateEmbedding — model=${model}, chars=${truncated.length}`);
+        debugLog(`[VoyageAdapter] generateEmbeddings batch — model=${model}, count=${texts.length}`);
         const requestBody = {
-            input: [truncated],
+            input: truncatedTexts,
             model,
             // We do NOT send output_dimension here because Voyage's API explicitly
             // restricts it to [256, 512, 1024, 2048] for MRL models. We will
             // manually slice the 1024-dim result down to 768 client-side.
         };
-        const response = await fetch(`${VOYAGE_API_BASE}/embeddings`, {
-            method: "POST",
-            headers: {
-                "Authorization": `Bearer ${this.apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(requestBody),
-        });
-        if (!response.ok) {
+        let response = null;
+        let retries = 0;
+        const maxRetries = 4;
+        const baseDelayMs = 15000; // 15 seconds base delay
+        while (true) {
+            response = await fetch(`${VOYAGE_API_BASE}/embeddings`, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (response.ok) {
+                break;
+            }
             const errorText = await response.text().catch(() => "unknown error");
+            if (response.status === 429 && retries < maxRetries) {
+                // Simple backoff: baseDelayMs * (retries + 1) -> 15s, 30s, 45s, 60s
+                const delay = baseDelayMs * (retries + 1);
+                retries++;
+                debugLog(`[VoyageAdapter] Rate limited (429). Retrying in ${delay}ms... (Attempt ${retries}/${maxRetries}): ${errorText.substring(0, 50)}...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                continue;
+            }
             throw new Error(`[VoyageAdapter] API request failed — status=${response.status}: ${errorText}`);
         }
         const data = (await response.json());
-        let embedding = data?.data?.[0]?.embedding;
-        if (!Array.isArray(embedding)) {
-            throw new Error("[VoyageAdapter] Unexpected response format — no embedding array found");
-        }
-        // Client-side MRL Truncation: 
-        // Voyage models returning 1024 dims can be safely sliced to 768 since they 
-        // are trained with Matryoshka Representation Learning.
-        if (embedding.length > EMBEDDING_DIMS) {
-            embedding = embedding.slice(0, EMBEDDING_DIMS);
-        }
-        // Dimension guard: Prism's DB schema requires exactly 768 dims.
-        if (embedding.length !== EMBEDDING_DIMS) {
-            throw new Error(`[VoyageAdapter] Embedding dimension mismatch: expected ${EMBEDDING_DIMS}, ` +
-                `got ${embedding.length}. Make sure you are using a model that returns at least 768 dims.`);
+        const embeddings = data?.data?.map(d => d.embedding) || [];
+        if (embeddings.length !== texts.length) {
+            throw new Error(`[VoyageAdapter] Unexpected response length — expected ${texts.length}, got ${embeddings.length}`);
         }
-        debugLog(`[VoyageAdapter] Embedding generated — dims=${embedding.length}, ` +
+        const processedEmbeddings = embeddings.map(emb => {
+            let embedding = emb;
+            // Client-side MRL Truncation: 
+            // Voyage models returning 1024 dims can be safely sliced to 768 since they 
+            // are trained with Matryoshka Representation Learning.
+            if (embedding.length > EMBEDDING_DIMS) {
+                embedding = embedding.slice(0, EMBEDDING_DIMS);
+            }
+            // Dimension guard: Prism's DB schema requires exactly 768 dims.
+            if (embedding.length !== EMBEDDING_DIMS) {
+                throw new Error(`[VoyageAdapter] Embedding dimension mismatch: expected ${EMBEDDING_DIMS}, ` +
+                    `got ${embedding.length}. Make sure you are using a model that returns at least 768 dims.`);
+            }
+            return embedding;
+        });
+        debugLog(`[VoyageAdapter] Batch embeddings generated — count=${processedEmbeddings.length}, ` +
             `tokens_used=${data.usage?.total_tokens ?? "unknown"}`);
-        return embedding;
+        return processedEmbeddings;
+    }
+    async generateEmbedding(text) {
+        if (!text || !text.trim()) {
+            throw new Error("[VoyageAdapter] generateEmbedding called with empty text");
+        }
+        const results = await this.generateEmbeddings([text]);
+        return results[0];
     }
 }

package/dist/utils/llm/factory.js

@@ -117,6 +117,10 @@ export function getLLMProvider() {
             generateText: textAdapter.generateText.bind(textAdapter),
             generateEmbedding: embedAdapter.generateEmbedding.bind(embedAdapter),
         };
+        // Wire batch embeddings if the embed adapter supports it (e.g. VoyageAdapter).
+        if (embedAdapter.generateEmbeddings) {
+            composed.generateEmbeddings = embedAdapter.generateEmbeddings.bind(embedAdapter);
+        }
         // Pass VLM support through from the text adapter if it exists.
         // generateImageDescription is a text-generation concern (it calls the
         // text/vision model, not the embedding model). The text adapter owns it.
@@ -141,6 +145,9 @@ export function getLLMProvider() {
             generateText: fallback.generateText.bind(fallback),
             generateEmbedding: fallback.generateEmbedding.bind(fallback),
         };
+        if (typeof fallback.generateEmbeddings === 'function') {
+            fallbackComposed.generateEmbeddings = fallback.generateEmbeddings.bind(fallback);
+        }
         if (fallback.generateImageDescription) {
             fallbackComposed.generateImageDescription = fallback.generateImageDescription.bind(fallback);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "7.8.4",
+  "version": "7.8.7",
   "mcpName": "io.github.dcostenco/prism-mcp",
   "description": "The Mind Palace for AI Agents — a true Cognitive Architecture with Hebbian learning (episodic→semantic consolidation), ACT-R spreading activation (multi-hop causal reasoning), uncertainty-aware rejection gates (agents that know when they don't know), adversarial evaluation (anti-sycophancy), fail-closed Dark Factory pipelines, persistent memory (SQLite/Supabase), multi-agent Hivemind, time travel & visual dashboard. Zero-config local mode.",
   "module": "index.ts",