prism-mcp-server 7.8.7 → 8.0.0

package/README.md

@@ -12,7 +12,7 @@
 
 **Your AI agent forgets everything between sessions. Prism fixes that — then teaches it to think.**
 
-Prism v7.8 is a true **Cognitive Architecture** inspired by human brain mechanics. Beyond flat vector search, your agent now forms principles from experience, follows causal trains of thought, and possesses the self-awareness to know when it lacks information. **Your agents don't just remember; they learn.**
+Prism v8.0 is a true **Cognitive Architecture** inspired by human brain mechanics. The new **Synapse Engine** replaces flat vector search with pure multi-hop graph propagation — your agent now follows causal trains of thought across memory, forms principles from experience, and knows when it lacks information. **Your agents don't just remember; they think.**
 
 ```bash
 npx -y prism-mcp-server
@@ -28,6 +28,7 @@ Works with **Claude Desktop · Claude Code · Cursor · Windsurf · Cline · Gem
 - [Setup Guides](#setup-guides)
 - [Universal Import: Bring Your History](#universal-import-bring-your-history)
 - [What Makes Prism Different](#what-makes-prism-different)
+- [Synapse Engine (v8.0)](#-synapse-engine-v80)
 - [Cognitive Architecture (v7.8)](#-cognitive-architecture-v78)
 - [Data Privacy & Egress](#data-privacy--egress)
 - [Use Cases](#use-cases)
@@ -54,7 +55,7 @@ Prism has three pillars:
 
 1. **🧠 Cognitive Memory** — Memories are ranked like a human brain: recently and frequently accessed context surfaces first, while stale context fades naturally via ACT-R activation decay. Raw experience consolidates into semantic principles through Hebbian learning. The result is retrieval quality that no flat vector search can match. *(See [Cognitive Architecture](#-cognitive-architecture-v78) and [Scientific Foundation](#-scientific-foundation).)*
 
-2. **🔗 Multi-Hop Reasoning** — When your agent searches for "Error X", Prism doesn't just find logs mentioning "Error X". Spreading activation traverses the causal graph and brings back "Workaround Y", which is connected to "Architecture Decision Z" — a literal train of thought. *(See [Cognitive Architecture](#-cognitive-architecture-v78).)*
+2. **⚡ Synapse Engine (GraphRAG)** — When your agent searches for "Error X", the Synapse Engine doesn't just find logs mentioning "Error X". Multi-hop energy propagation traverses the causal graph — dampened by fan effect, bounded by lateral inhibition — and surfaces "Workaround Y" connected to "Architecture Decision Z". Nodes discovered exclusively via graph traversal are tagged `[🌐 Synapse]` so you can *see* the engine working. *(See [Synapse Engine](#-synapse-engine-v80).)*
 
 3. **🏭 Autonomous Execution (Dark Factory)** — When you're ready, Prism can run coding tasks end-to-end with a fail-closed pipeline where an adversarial evaluator catches bugs the generator missed — before you ever see the PR. *(See [Dark Factory](#-dark-factory--adversarial-autonomous-pipelines).)*
 
@@ -459,6 +460,53 @@ When you trigger a Dark Factory pipeline, Prism doesn't just run your task — i
 
 ---
 
+## ⚡ Synapse Engine (v8.0)
+
+> *Standard RAG retrieves documents. GraphRAG traverses relationships. The Synapse Engine does both — a pure, storage-agnostic multi-hop propagation engine that turns your agent's memory into an associative reasoning network.*
+
+The Synapse Engine (v8.0) replaces the legacy SQL-coupled spreading activation with a **pure functional graph propagation core** inspired by ACT-R cognitive architecture. It is Prism's native, low-latency GraphRAG solution — no external graph database required.
+
+### Before vs After
+
+| | **v7.x (Standard RAG)** | **v8.0 (Synapse Engine)** |
+|---|---|---|
+| **Query** | "Tell me about Project Apollo" | "Tell me about Project Apollo" |
+| **Retrieval** | Returns the design doc (1 hop, cosine match) | Returns the design doc → follows `caused_by` edge to a developer's debugging session → discovers an old Slack thread about a critical auth bug |
+| **Agent output** | Summarizes the design doc | Summarizes the design doc **and warns about the unresolved auth issue** |
+| **Discovery tag** | — | `[🌐 Synapse]` marks the auth bug node, proving the engine found context the user didn't ask for |
+
+### How It Works
+
+```
+  Query: "Project Apollo status"
+              │
+  ┌───────────┼───────────────┐
+  ▼           ▼               ▼
+[Design    [Sprint          [Deployment
+  Doc]      Retro]            Log]
+  │ 1.0       │ 0.8            │ 0.6    ← semantic anchors
+  │           │                │
+  ▼           ▼                ▼
+[Dev       [Auth Bug      [Perf         ← Synapse discovered
+  Profile    Thread  🌐]    Regression 🌐]   (multi-hop)
+  0.42]      0.38]          0.31]
+```
+
+**Key design decisions:**
+
+| Mechanism | Purpose |
+|---|---|
+| **Dampened Fan Effect** (`1/ln(degree+e)`) | Prevents hub nodes from flooding results |
+| **Asymmetric Propagation** (fwd 100%, back 50%) | Preserves causal directionality |
+| **Cyclic Loop Prevention** (`visitedEdges` set) | Prevents infinite energy amplification |
+| **Sigmoid Normalization** | Structural scores can't overwhelm semantic base |
+| **Lateral Inhibition** | Caps output to top-K most energized nodes |
+| **Hybrid Scoring** (70% semantic / 30% structural) | Base relevance always matters |
+
+> 💡 Synapse is **non-fatal** — if the graph traversal fails for any reason, search gracefully returns the original semantic matches. Zero risk of degraded search.
+
+---
+
 ## 🧠 Cognitive Architecture (v7.8)
 
 > *Prism v7.8 is our biggest leap forward yet. We have moved beyond flat vector search and implemented a true Cognitive Architecture inspired by human brain mechanics. With the new ACT-R Spreading Activation Engine, Episodic-to-Semantic memory consolidation, and Uncertainty-Aware Rejection Gates, Prism doesn't just store logs anymore — it forms principles, follows causal trains of thought, and possesses the self-awareness to know when it lacks information.*
@@ -691,9 +739,10 @@ The Generator strips the `console.log`, resubmits, and the next `EVALUATE` retur
 
 ## 🆕 What's New
 
-> **Current release: v7.8.7 — Cognitive Architecture**
+> **Current release: v8.0.0 — Synapse Engine**
 
-- 🧠 **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)
+- ⚡ **v8.0.0 — Synapse Engine:** Pure, storage-agnostic multi-hop graph propagation engine replaces the legacy SQL-coupled spreading activation. O(T × M) bounded ACT-R energy propagation with dampened fan effect, asymmetric bidirectional flow, cyclic loop prevention, and sigmoid normalization. Full integration into both SQLite and Supabase backends. 5 new config knobs. Battle-hardened with NaN guards, config clamping, non-fatal enrichment, and 16 passing tests. **Memory search now follows the causal graph, not just keywords.** → [Synapse Engine](#synapse-engine-v80)
+- 🧠 **v7.8.x — Cognitive Architecture:** Episodic-to-Semantic consolidation (Hebbian learning), ACT-R Spreading Activation with multi-hop causal reasoning, Uncertainty-Aware Rejection Gate, and Dynamic Fast Weight Decay. Validated by **LoCoMo-Plus benchmark**. → [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.
@@ -937,6 +986,11 @@ Requires `PRISM_DARK_FACTORY_ENABLED=true`.
 | `PRISM_ACTR_WEIGHT_ACTIVATION` | No | Composite score ACT-R activation weight (default: `0.3`) |
 | `PRISM_ACTR_ACCESS_LOG_RETENTION_DAYS` | No | Days before access logs are pruned by background scheduler (default: `90`) |
 | `PRISM_DARK_FACTORY_ENABLED` | No | `"true"` to enable Dark Factory autonomous pipeline tools (`session_start_pipeline`, `session_check_pipeline_status`, `session_abort_pipeline`) |
+| `PRISM_SYNAPSE_ENABLED` | No | `"true"` (default) to enable Synapse Engine graph propagation in search results |
+| `PRISM_SYNAPSE_ITERATIONS` | No | Propagation iterations (default: `3`). Higher = deeper graph traversal |
+| `PRISM_SYNAPSE_SPREAD_FACTOR` | No | Energy decay multiplier per hop (default: `0.8`). Range: 0.0–1.0 |
+| `PRISM_SYNAPSE_LATERAL_INHIBITION` | No | Max nodes returned by Synapse (default: `7`, min: `1`) |
+| `PRISM_SYNAPSE_SOFT_CAP` | No | Max candidate pool size during propagation (default: `20`, min: `1`) |
 
 </details>
 
@@ -964,8 +1018,8 @@ Prism is a **stdio-based MCP server** that manages persistent agent memory. Here
 │  └──────┬───────┘  └──────────────┘  └────────────────┘  │
 │         ↕                                                │
 │  ┌────────────────────────────────────────────────────┐  │
-│  │  Cognitive Engine (v7.8)                           │  │
-│  │  • ACT-R Spreading Activation (multi-hop)         │  │
+│  │  Cognitive Engine (v8.0)                           │  │
+│  │  • Synapse Engine (pure multi-hop propagation)    │  │
 │  │  • Episodic → Semantic Consolidation (Hebbian)    │  │
 │  │  • Uncertainty-Aware Rejection Gate               │  │
 │  │  • LoCoMo-Plus Benchmark Validation               │  │
@@ -1068,10 +1122,11 @@ Prism has evolved from smart session logging into a **cognitive memory architect
 
 ## 📦 Milestones & Roadmap
 
-> **Current: v7.8.7** — Cognitive Architecture ([CHANGELOG](CHANGELOG.md))
+> **Current: v8.0.0** — Synapse Engine ([CHANGELOG](CHANGELOG.md))
 
 | Release | Headline |
 |---------|----------|
+| **v8.0** | ⚡ Synapse Engine — Pure multi-hop GraphRAG propagation, storage-agnostic, NaN-hardened, `[🌐 Synapse]` discovery tags |
 | **v7.8** | 🧠 Cognitive Architecture — Hebbian consolidation, multi-hop reasoning, rejection gate, dynamic decay |
 | **v7.7** | 🌐 Cloud-Native SSE Transport |
 | **v7.5** | 🩺 Intent Health Dashboard + Security Hardening |

package/dist/config.js

@@ -268,3 +268,17 @@ export const PRISM_DARK_FACTORY_ENABLED = process.env.PRISM_DARK_FACTORY_ENABLED
 export const PRISM_DARK_FACTORY_POLL_MS = parseInt(process.env.PRISM_DARK_FACTORY_POLL_MS || "30000", 10);
 /** Default max wall-clock time per pipeline (ms). Default: 15 minutes. */
 export const PRISM_DARK_FACTORY_MAX_RUNTIME_MS = parseInt(process.env.PRISM_DARK_FACTORY_MAX_RUNTIME_MS || "900000", 10);
+// ─── v8.0: Synapse — Spreading Activation Engine ──────────────
+// Multi-hop energy propagation through memory_links graph.
+// Enabled by default. Set PRISM_SYNAPSE_ENABLED=false to fall back
+// to 1-hop candidateScopedSpreadingActivation (v7.0 behavior).
+/** Master switch for the Synapse engine. Enabled by default (opt-out). */
+export const PRISM_SYNAPSE_ENABLED = (process.env.PRISM_SYNAPSE_ENABLED ?? "true") !== "false";
+/** Number of propagation iterations (depth). Higher = deeper traversal, more latency. (Default: 3) */
+export const PRISM_SYNAPSE_ITERATIONS = parseInt(process.env.PRISM_SYNAPSE_ITERATIONS || "3", 10);
+/** Energy attenuation per hop. Must be < 1.0 for convergence. (Default: 0.8) */
+export const PRISM_SYNAPSE_SPREAD_FACTOR = parseFloat(process.env.PRISM_SYNAPSE_SPREAD_FACTOR || "0.8");
+/** Hard cap on final output nodes (lateral inhibition). (Default: 7) */
+export const PRISM_SYNAPSE_LATERAL_INHIBITION = parseInt(process.env.PRISM_SYNAPSE_LATERAL_INHIBITION || "7", 10);
+/** Soft cap on active nodes per iteration (prevents explosion). (Default: 20) */
+export const PRISM_SYNAPSE_SOFT_CAP = parseInt(process.env.PRISM_SYNAPSE_SOFT_CAP || "20", 10);

package/dist/dashboard/ui.js

@@ -1253,7 +1253,9 @@ Example:\n## Dev Rules\n- Always write tests first\n- Use TypeScript strict mode
               onchange="onEmbeddingProviderChange(this.value)">
               <option value="auto">🔄 Auto (same as Text Provider)</option>
               <option value="gemini">🔵 Gemini</option>
-              <option value="openai">🟢 OpenAI / Ollama</option>
+              <option value="openai">🟢 OpenAI</option>
+              <option value="voyage">🔮 Voyage AI</option>
+              <option value="ollama">🟠 Ollama (Local)</option>
             </select>
           </div>
 
@@ -1261,7 +1263,7 @@ Example:\n## Dev Rules\n- Always write tests first\n- Use TypeScript strict mode
           <div id="anthropic-embed-warning" style="display:none;margin-top:0.5rem;padding:0.5rem 0.75rem;background:rgba(251,146,60,0.1);border:1px solid rgba(251,146,60,0.3);border-radius:6px;font-size:0.78rem;color:#fb923c;line-height:1.5">
             ⚠️ <strong>Anthropic has no native embedding API.</strong>
             Auto mode will route embeddings to <strong>Gemini</strong>.
-            Set Embedding Provider to <strong>OpenAI / Ollama</strong> to use a local model (e.g. <code>nomic-embed-text</code>).
+            Set Embedding Provider to <strong>Ollama (Local)</strong> for free local embeddings, or <strong>Voyage AI</strong> for the Anthropic-recommended cloud pairing.
           </div>
 
           <!-- OpenAI embedding model field (shown when embedding_provider = openai) -->
@@ -1269,7 +1271,7 @@ Example:\n## Dev Rules\n- Always write tests first\n- Use TypeScript strict mode
             <div class="setting-row">
               <div>
                 <div class="setting-label">Embedding Model</div>
-                <div class="setting-desc">Must output 768 dims. Ollama: nomic-embed-text · OpenAI: text-embedding-3-small</div>
+                <div class="setting-desc">Must output 768 dims. Default: text-embedding-3-small</div>
               </div>
               <input type="text" id="input-openai-embedding-model"
                 placeholder="text-embedding-3-small"
@@ -1279,9 +1281,61 @@ Example:\n## Dev Rules\n- Always write tests first\n- Use TypeScript strict mode
             </div>
           </div>
 
+          <!-- Voyage AI embedding fields (shown when embedding_provider = voyage) -->
+          <div id="embed-fields-voyage" style="display:none">
+            <div class="setting-row">
+              <div>
+                <div class="setting-label">Voyage API Key</div>
+                <div class="setting-desc">Get one free at <a href="https://dash.voyageai.com" target="_blank" style="color:var(--accent)">dash.voyageai.com</a></div>
+              </div>
+              <input type="password" id="input-voyage-api-key"
+                placeholder="pa-…"
+                style="padding: 0.2rem 0.5rem; background: var(--bg-hover); color: var(--text-primary); border: 1px solid var(--border-color); border-radius: 4px; font-size: 0.85rem; font-family: var(--font-mono); width: 180px;"
+                onchange="saveBootSetting('VOYAGE_API_KEY', this.value)"
+                oninput="clearTimeout(this._pv); var self=this; this._pv=setTimeout(function(){saveBootSetting('VOYAGE_API_KEY',self.value)},800)" />
+            </div>
+            <div class="setting-row">
+              <div>
+                <div class="setting-label">Voyage Model</div>
+                <div class="setting-desc">voyage-code-3 (code) · voyage-3 (general). Both MRL → 768 dims.</div>
+              </div>
+              <input type="text" id="input-voyage-model"
+                placeholder="voyage-code-3"
+                style="padding: 0.2rem 0.5rem; background: var(--bg-hover); color: var(--text-primary); border: 1px solid var(--border-color); border-radius: 4px; font-size: 0.85rem; font-family: var(--font-mono); width: 160px;"
+                onchange="saveBootSetting('voyage_model', this.value)"
+                oninput="clearTimeout(this._pvm); var self=this; this._pvm=setTimeout(function(){saveBootSetting('voyage_model',self.value)},800)" />
+            </div>
+          </div>
+
+          <!-- Ollama embedding fields (shown when embedding_provider = ollama) -->
+          <div id="embed-fields-ollama" style="display:none">
+            <div class="setting-row">
+              <div>
+                <div class="setting-label">Ollama Base URL</div>
+                <div class="setting-desc">Where Ollama is running locally</div>
+              </div>
+              <input type="text" id="input-ollama-base-url"
+                placeholder="http://localhost:11434"
+                style="padding: 0.2rem 0.5rem; background: var(--bg-hover); color: var(--text-primary); border: 1px solid var(--border-color); border-radius: 4px; font-size: 0.85rem; font-family: var(--font-mono); width: 220px;"
+                onchange="saveBootSetting('ollama_base_url', this.value)"
+                oninput="clearTimeout(this._pou); var self=this; this._pou=setTimeout(function(){saveBootSetting('ollama_base_url',self.value)},800)" />
+            </div>
+            <div class="setting-row">
+              <div>
+                <div class="setting-label">Embedding Model</div>
+                <div class="setting-desc">Must output 768 dims. <code>nomic-embed-text</code> recommended.</div>
+              </div>
+              <input type="text" id="input-ollama-model"
+                placeholder="nomic-embed-text"
+                style="padding: 0.2rem 0.5rem; background: var(--bg-hover); color: var(--text-primary); border: 1px solid var(--border-color); border-radius: 4px; font-size: 0.85rem; font-family: var(--font-mono); width: 180px;"
+                onchange="saveBootSetting('ollama_model', this.value)"
+                oninput="clearTimeout(this._pom); var self=this; this._pom=setTimeout(function(){saveBootSetting('ollama_model',self.value)},800)" />
+            </div>
+          </div>
+
           <div style="margin-top:1rem;padding:0.6rem 0.8rem;background:rgba(139,92,246,0.08);border:1px solid rgba(139,92,246,0.2);border-radius:6px;font-size:0.78rem;color:var(--text-secondary);line-height:1.5">
-            💡 <strong>Cost-optimized setup:</strong> Text Provider → <code>Anthropic</code>, Embedding Provider → <code>OpenAI / Ollama</code>.<br>
-            Use Claude 3.5 Sonnet for reasoning &amp; <code>nomic-embed-text</code> (free, local) for embeddings.
+            💡 <strong>Zero-cost setup:</strong> Text Provider → <code>Anthropic</code>, Embedding Provider → <code>Ollama (Local)</code>.<br>
+            Use Claude for reasoning &amp; <code>nomic-embed-text</code> (free, local, 768-dim native) for embeddings.
           </div>
 
           <span class="setting-saved" id="savedToastProviders">Saved ✓</span>
@@ -3135,8 +3189,10 @@ function onTextProviderChange(value) {
 // Called when the EMBEDDING provider dropdown changes.
 function onEmbeddingProviderChange(value) {
     var textVal = document.getElementById('select-text-provider').value;
-    // Show the OpenAI embedding model field only when embedding=openai
+    // Show provider-specific fields based on the selected embedding provider
     document.getElementById('embed-fields-openai').style.display = value === 'openai' ? '' : 'none';
+    document.getElementById('embed-fields-voyage').style.display = value === 'voyage' ? '' : 'none';
+    document.getElementById('embed-fields-ollama').style.display = value === 'ollama' ? '' : 'none';
     refreshAnthropicWarning(textVal, value);
     saveBootSetting('embedding_provider', value);
 }
@@ -3174,7 +3230,17 @@ function loadAiProviderSettings() {
                     if (embedSel)
                         embedSel.value = embedProvider;
                     document.getElementById('embed-fields-openai').style.display = embedProvider === 'openai' ? '' : 'none';
+                    document.getElementById('embed-fields-voyage').style.display = embedProvider === 'voyage' ? '' : 'none';
+                    document.getElementById('embed-fields-ollama').style.display = embedProvider === 'ollama' ? '' : 'none';
                     refreshAnthropicWarning(textProvider, embedProvider);
+                    var vKey = document.getElementById('input-voyage-api-key');
+                    if (vKey) vKey.placeholder = s.VOYAGE_API_KEY ? '(key saved — paste to update)' : 'pa-…';
+                    var vMod = document.getElementById('input-voyage-model');
+                    if (vMod && s.voyage_model) vMod.value = s.voyage_model;
+                    var olUrl = document.getElementById('input-ollama-base-url');
+                    if (olUrl && s.ollama_base_url) olUrl.value = s.ollama_base_url;
+                    var olMod = document.getElementById('input-ollama-model');
+                    if (olMod && s.ollama_model) olMod.value = s.ollama_model;
                     gKey = document.getElementById('input-google-api-key');
                     if (gKey)
                         gKey.placeholder = s.GOOGLE_API_KEY ? '(key saved — paste to update)' : 'AIza…';

package/dist/memory/synapseEngine.js

@@ -0,0 +1,222 @@
+/**
+ * Synapse — Spreading Activation Engine (v8.0)
+ *
+ * ═══════════════════════════════════════════════════════════════════
+ * PURPOSE:
+ *   Multi-hop energy propagation through the memory_links graph.
+ *   Replaces both the old SQL-coupled spreadingActivation.ts AND the
+ *   shallow 1-hop candidateScopedSpreadingActivation() from v7.0.
+ *
+ * PAPER BASIS:
+ *   ACT-R spreading activation (Anderson, 2004) extended with:
+ *   - Dampened fan effect: 1/ln(degree + e)
+ *   - Asymmetric bidirectional flow (forward 100%, backward 50%)
+ *   - Lateral inhibition (soft cap per iteration, hard cap on output)
+ *   - Visited-edge tracking to prevent cyclic energy amplification
+ *
+ * DESIGN:
+ *   All functions are PURE — zero I/O, zero imports from storage or SQL.
+ *   Link data is fetched via a LinkFetcher callback injected by the caller
+ *   (SqliteStorage, SupabaseStorage, or test mock).
+ *   NOTE: debugLog (stderr diagnostic) is the sole side effect — it only
+ *   fires when PRISM_DEBUG_LOGGING=true and does not affect correctness.
+ *
+ * PERFORMANCE:
+ *   Bounded by O(T × softCap) where T=iterations (default 3) and
+ *   softCap=20. Worst case: 3 × 20 node expansions = 60 link fetches.
+ *   Typical latency: 5-15ms on SQLite.
+ *
+ * FILES THAT IMPORT THIS:
+ *   - src/storage/sqlite.ts (search methods)
+ *   - src/tools/graphHandlers.ts (ACT-R re-ranking pipeline)
+ * ═══════════════════════════════════════════════════════════════════
+ */
+import { debugLog } from "../utils/logger.js";
+// ─── Default Configuration ────────────────────────────────────
+export const DEFAULT_SYNAPSE_CONFIG = {
+    iterations: 3,
+    spreadFactor: 0.8,
+    lateralInhibition: 7,
+    softCap: 20,
+};
+// ─── Sigmoid Normalization ────────────────────────────────────
+/**
+ * Squash activation energy into [0, 1] using a parameterized sigmoid.
+ *
+ * This prevents raw activation energy from overpowering the similarity
+ * component in the hybrid score. Without normalization, a node with
+ * 10 inbound paths could accumulate energy > 5.0, making the 0.3 weight
+ * mathematically dominate the 0.7 similarity weight.
+ *
+ * Calibration:
+ *   midpoint = 0.5 — an activation of 0.5 maps to sigmoid output 0.5
+ *   steepness = 2.0 — moderate discrimination
+ *
+ * @param energy - Raw accumulated activation energy
+ * @returns Normalized energy in (0, 1)
+ */
+export function normalizeActivationEnergy(energy) {
+    if (!Number.isFinite(energy)) {
+        return energy > 0 ? 1.0 : 0.0;
+    }
+    const midpoint = 0.5;
+    const steepness = 2.0;
+    const exponent = -steepness * (energy - midpoint);
+    if (exponent > 500)
+        return 0;
+    if (exponent < -500)
+        return 1;
+    return 1 / (1 + Math.exp(exponent));
+}
+// ─── Core Engine ──────────────────────────────────────────────
+/**
+ * Propagate activation energy through the memory_links graph.
+ *
+ * Algorithm:
+ *   1. Initialize active nodes with anchor similarity scores
+ *   2. For each iteration:
+ *      a. Fetch ALL links connected to active nodes (via LinkFetcher)
+ *      b. Compute per-source fan effect: 1 / ln(out-degree + e)
+ *      c. Forward flow: source → target at S × strength × sourceEnergy / dampedFan
+ *      d. Backward flow: target → source at (S × 0.5) × strength × targetEnergy
+ *      e. Track visited edges to prevent cyclic re-traversal
+ *      f. Soft lateral inhibition: keep top-softCap nodes
+ *   3. Final lateral inhibition: return top-M nodes
+ *
+ * @param anchors - Map of entry ID → initial activation (typically similarity score)
+ * @param linkFetcher - Async callback to batch-fetch links
+ * @param config - Engine configuration (uses defaults if omitted)
+ * @returns Array of SynapseResult sorted by activationEnergy descending
+ */
+export async function propagateActivation(anchors, linkFetcher, config = {}) {
+    const startMs = performance.now();
+    const cfg = { ...DEFAULT_SYNAPSE_CONFIG, ...config };
+    // Validate: spreadFactor must be < 1.0 for convergence guarantee
+    if (cfg.spreadFactor >= 1.0) {
+        debugLog(`[synapse] WARNING: spreadFactor=${cfg.spreadFactor} >= 1.0, clamping to 0.99`);
+        cfg.spreadFactor = 0.99;
+    }
+    // Clamp minimums to prevent silent result drops
+    if (cfg.lateralInhibition < 1)
+        cfg.lateralInhibition = 1;
+    if (cfg.softCap < 1)
+        cfg.softCap = 1;
+    // State: current activation energy per node
+    let activeNodes = new Map();
+    // Track minimum hop distance from any anchor
+    const hopDistance = new Map();
+    // Track visited edges to prevent cyclic re-traversal
+    const visitedEdges = new Set();
+    // Total edges traversed for telemetry
+    let totalEdgesTraversed = 0;
+    // Initialize with anchor scores
+    for (const [id, score] of anchors) {
+        activeNodes.set(id, score);
+        hopDistance.set(id, 0);
+    }
+    // Short-circuit: no iterations = return anchors as-is
+    if (cfg.iterations <= 0 || anchors.size === 0) {
+        const results = buildResults(activeNodes, anchors, hopDistance, cfg.lateralInhibition);
+        return {
+            results,
+            telemetry: buildTelemetry(results, anchors, 0, 0, startMs),
+        };
+    }
+    // ─── Propagation Loop ────────────────────────────────────
+    for (let t = 0; t < cfg.iterations; t++) {
+        const currentIds = Array.from(activeNodes.keys());
+        if (currentIds.length === 0)
+            break;
+        // Fetch ALL links connected to currently active nodes
+        // No global LIMIT — engine controls explosion via softCap
+        let edges;
+        try {
+            edges = await linkFetcher(currentIds);
+        }
+        catch (err) {
+            debugLog(`[synapse] Link fetch failed at iteration ${t} (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            break;
+        }
+        totalEdgesTraversed += edges.length;
+        // Compute out-degree per active source node (for fan effect)
+        const outDegree = new Map();
+        for (const edge of edges) {
+            if (activeNodes.has(edge.source_id)) {
+                outDegree.set(edge.source_id, (outDegree.get(edge.source_id) || 0) + 1);
+            }
+        }
+        // Next-iteration activation: starts with current values (activation persists)
+        const nextNodes = new Map(activeNodes);
+        for (const edge of edges) {
+            const edgeKey = `${edge.source_id}->${edge.target_id}`;
+            const strength = Number.isFinite(edge.strength) ? Math.max(0, Math.min(1, edge.strength)) : 0;
+            // ── Forward flow: source is active, flows to target ──
+            if (activeNodes.has(edge.source_id) && !visitedEdges.has(edgeKey)) {
+                visitedEdges.add(edgeKey);
+                const sourceEnergy = activeNodes.get(edge.source_id);
+                const degree = outDegree.get(edge.source_id) || 1;
+                // Dampened fan effect: prevents hub nodes from broadcasting equally
+                const dampedFan = Math.log(degree + Math.E);
+                const flow = cfg.spreadFactor * (strength * sourceEnergy / dampedFan);
+                nextNodes.set(edge.target_id, (nextNodes.get(edge.target_id) || 0) + flow);
+                // Track hop distance (minimum)
+                const sourceHops = hopDistance.get(edge.source_id) ?? 0;
+                const currentTargetHops = hopDistance.get(edge.target_id);
+                if (currentTargetHops === undefined || sourceHops + 1 < currentTargetHops) {
+                    hopDistance.set(edge.target_id, sourceHops + 1);
+                }
+            }
+            // ── Backward flow: target is active, flows backward to source at 50% ──
+            const reverseEdgeKey = `${edge.target_id}->${edge.source_id}`;
+            if (activeNodes.has(edge.target_id) && !visitedEdges.has(reverseEdgeKey)) {
+                visitedEdges.add(reverseEdgeKey);
+                const targetEnergy = activeNodes.get(edge.target_id);
+                const flow = (cfg.spreadFactor * 0.5) * (strength * targetEnergy);
+                nextNodes.set(edge.source_id, (nextNodes.get(edge.source_id) || 0) + flow);
+                // Track hop distance for backward discoveries
+                const targetHops = hopDistance.get(edge.target_id) ?? 0;
+                const currentSourceHops = hopDistance.get(edge.source_id);
+                if (currentSourceHops === undefined || targetHops + 1 < currentSourceHops) {
+                    hopDistance.set(edge.source_id, targetHops + 1);
+                }
+            }
+        }
+        // Soft lateral inhibition: keep only top-softCap nodes to prevent explosion
+        const sorted = Array.from(nextNodes.entries()).sort((a, b) => b[1] - a[1]);
+        activeNodes = new Map(sorted.slice(0, cfg.softCap));
+    }
+    // ─── Final Output ────────────────────────────────────────
+    const results = buildResults(activeNodes, anchors, hopDistance, cfg.lateralInhibition);
+    return {
+        results,
+        telemetry: buildTelemetry(results, anchors, cfg.iterations, totalEdgesTraversed, startMs),
+    };
+}
+// ─── Helpers ──────────────────────────────────────────────────
+function buildResults(activeNodes, anchors, hopDistance, lateralInhibition) {
+    // Sort by activation energy descending, then apply hard lateral inhibition
+    const sorted = Array.from(activeNodes.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, lateralInhibition);
+    return sorted.map(([id, energy]) => ({
+        id,
+        activationEnergy: energy,
+        hopsFromAnchor: hopDistance.get(id) ?? 0,
+        isDiscovered: !anchors.has(id),
+    }));
+}
+function buildTelemetry(results, anchors, iterations, edgesTraversed, startMs) {
+    const energies = results.map(r => r.activationEnergy);
+    const discovered = results.filter(r => !anchors.has(r.id)).length;
+    return {
+        nodesReturned: results.length,
+        nodesDiscovered: discovered,
+        maxActivationEnergy: energies.length > 0 ? Math.max(...energies) : 0,
+        avgActivationEnergy: energies.length > 0
+            ? energies.reduce((a, b) => a + b, 0) / energies.length
+            : 0,
+        iterationsPerformed: iterations,
+        edgesTraversed,
+        durationMs: Math.round(performance.now() - startMs),
+    };
+}

package/dist/observability/graphMetrics.js

@@ -66,6 +66,7 @@ let testMe = createFreshTestMeMetrics();
 let schedulerSynthesis = createFreshSchedulerMetrics();
 let pruning = createFreshPruningMetrics();
 let cognitive = createFreshCognitiveMetrics();
+let synapse = createFreshSynapseMetrics();
 function createFreshSynthesisMetrics() {
     return {
         runs_total: 0,
@@ -137,6 +138,18 @@ function createFreshCognitiveMetrics() {
         duration_buffer: new DurationBuffer(),
     };
 }
+function createFreshSynapseMetrics() {
+    return {
+        evaluations_total: 0,
+        nodes_returned_last: 0,
+        nodes_discovered_last: 0,
+        edges_traversed_last: 0,
+        iterations_performed_last: 0,
+        max_activation_last: 0,
+        last_run_at: null,
+        duration_buffer: new DurationBuffer(),
+    };
+}
 function emitGraphEvent(event) {
     try {
         debugLog(JSON.stringify(event));
@@ -298,6 +311,26 @@ export function recordCognitiveRoute(data) {
         duration_ms: data.duration_ms,
     });
 }
+export function recordSynapseTelemetry(data) {
+    const now = new Date().toISOString();
+    synapse.evaluations_total++;
+    synapse.last_run_at = now;
+    synapse.nodes_returned_last = data.nodesReturned;
+    synapse.nodes_discovered_last = data.nodesDiscovered;
+    synapse.edges_traversed_last = data.edgesTraversed;
+    synapse.iterations_performed_last = data.iterationsPerformed;
+    synapse.max_activation_last = data.maxActivationEnergy;
+    synapse.duration_buffer.push(data.durationMs);
+    emitGraphEvent({
+        event: "synapse_propagation",
+        nodes_returned: data.nodesReturned,
+        nodes_discovered: data.nodesDiscovered,
+        edges_traversed: data.edgesTraversed,
+        iterations: data.iterationsPerformed,
+        max_activation: data.maxActivationEnergy,
+        duration_ms: data.durationMs,
+    });
+}
 // ─── Warning Flag Computation ────────────────────────────────────
 function computeWarningFlags() {
     // Quality warning: >85% of candidates are below threshold (min 50 candidates)
@@ -419,6 +452,16 @@ export function getGraphMetricsSnapshot() {
             last_confidence: cognitive.last_confidence,
             duration_p50_ms: cognitive.duration_buffer.getP50(),
         },
+        synapse: {
+            evaluations_total: synapse.evaluations_total,
+            nodes_returned_last: synapse.nodes_returned_last,
+            nodes_discovered_last: synapse.nodes_discovered_last,
+            edges_traversed_last: synapse.edges_traversed_last,
+            iterations_performed_last: synapse.iterations_performed_last,
+            max_activation_last: synapse.max_activation_last,
+            last_run_at: synapse.last_run_at,
+            duration_p50_ms: synapse.duration_buffer.getP50(),
+        },
         slo: computeSloMetrics(),
         warnings: computeWarningFlags(),
     };
@@ -430,6 +473,7 @@ export function resetGraphMetricsForTests() {
     schedulerSynthesis = createFreshSchedulerMetrics();
     pruning = createFreshPruningMetrics();
     cognitive = createFreshCognitiveMetrics();
+    synapse = createFreshSynapseMetrics();
     sweepDurationMsLast = 0;
     sweepLastAt = null;
 }

package/dist/storage/sqlite.js

@@ -21,7 +21,7 @@ import * as path from "path";
 import * as os from "os";
 import { randomUUID } from "crypto";
 import { AccessLogBuffer } from "../utils/accessLogBuffer.js";
-import { PRISM_ACTR_BUFFER_FLUSH_MS } from "../config.js";
+import { PRISM_ACTR_BUFFER_FLUSH_MS, PRISM_SYNAPSE_ENABLED, PRISM_SYNAPSE_ITERATIONS, PRISM_SYNAPSE_SPREAD_FACTOR, PRISM_SYNAPSE_LATERAL_INHIBITION, PRISM_SYNAPSE_SOFT_CAP, } from "../config.js";
 import { getSetting as cfgGet, setSetting as cfgSet, getAllSettings as cfgGetAll } from "./configStorage.js";
 import { debugLog } from "../utils/logger.js";
 import { SafetyController } from "../darkfactory/safetyController.js";
@@ -1388,8 +1388,7 @@ export class SqliteStorage {
                     decisions: r.decisions,
                     files_changed: r.files_changed,
                 }));
-                const { applySpreadingActivation } = await import("../memory/spreadingActivation.js");
-                const activated = await applySpreadingActivation(this.db, mappedAnchors, params.activation, params.userId);
+                const activated = await this.applySynapse(mappedAnchors, params.activation, params.userId);
                 return { count: activated.length, results: activated };
             }
             return { count: results.length, results };
@@ -1461,8 +1460,7 @@ export class SqliteStorage {
                 decisions: r.decisions,
                 files_changed: r.files_changed,
             }));
-            const { applySpreadingActivation } = await import("../memory/spreadingActivation.js");
-            const activated = await applySpreadingActivation(this.db, mappedAnchors, params.activation, params.userId);
+            const activated = await this.applySynapse(mappedAnchors, params.activation, params.userId);
             return { count: activated.length, results: activated };
         }
         return { count: results.length, results };
@@ -1514,8 +1512,7 @@ export class SqliteStorage {
                 last_accessed_at: r.last_accessed_at || null,
             }));
             if (params.activation?.enabled) {
-                const { applySpreadingActivation } = await import("../memory/spreadingActivation.js");
-                return applySpreadingActivation(this.db, baseResults, params.activation, params.userId);
+                return this.applySynapse(baseResults, params.activation, params.userId);
             }
             return baseResults;
         }
@@ -1608,8 +1605,7 @@ export class SqliteStorage {
                 debugLog(`[SqliteStorage] Tier-2 TurboQuant fallback: scored ${fallbackResult.rows.length} entries, ` +
                     `${scored.length} above threshold`);
                 if (params.activation?.enabled) {
-                    const { applySpreadingActivation } = await import("../memory/spreadingActivation.js");
-                    return applySpreadingActivation(this.db, baseResults, params.activation, params.userId);
+                    return this.applySynapse(baseResults, params.activation, params.userId);
                 }
                 return baseResults;
             }
@@ -1621,6 +1617,67 @@ export class SqliteStorage {
             }
         }
     }
+    // ─── Synapse Engine Integration ────────────────────────────────
+    async applySynapse(anchors, options, userId) {
+        if (!PRISM_SYNAPSE_ENABLED || !options.enabled || anchors.length === 0)
+            return anchors;
+        try {
+            const { propagateActivation, normalizeActivationEnergy } = await import("../memory/synapseEngine.js");
+            const { recordSynapseTelemetry } = await import("../observability/graphMetrics.js");
+            const anchorMap = new Map();
+            for (const a of anchors)
+                anchorMap.set(a.id, a.similarity ?? 1.0);
+            const { results, telemetry } = await propagateActivation(anchorMap, async (nodeIds) => this.getLinksForNodes(nodeIds, userId), {
+                iterations: options.iterations ?? PRISM_SYNAPSE_ITERATIONS,
+                spreadFactor: options.spreadFactor ?? PRISM_SYNAPSE_SPREAD_FACTOR,
+                lateralInhibition: options.lateralInhibition ?? PRISM_SYNAPSE_LATERAL_INHIBITION,
+                softCap: PRISM_SYNAPSE_SOFT_CAP,
+            });
+            recordSynapseTelemetry(telemetry);
+            const fullNodeMap = new Map();
+            for (const a of anchors)
+                fullNodeMap.set(a.id, a);
+            const finalIds = results.map(r => r.id);
+            const missingIds = finalIds.filter(id => !fullNodeMap.has(id));
+            if (missingIds.length > 0) {
+                const placeholders = missingIds.map(() => '?').join(',');
+                const missingQuery = `
+          SELECT id, project, summary, session_date, decisions, files_changed
+          FROM session_ledger
+          WHERE id IN (${placeholders}) AND deleted_at IS NULL AND user_id = ?
+        `;
+                const missingRes = await this.db.execute({ sql: missingQuery, args: [...missingIds, userId] });
+                for (const row of missingRes.rows) {
+                    fullNodeMap.set(row.id, {
+                        id: row.id,
+                        project: row.project,
+                        summary: row.summary,
+                        session_date: row.session_date,
+                        decisions: this.parseJsonColumn(row.decisions),
+                        files_changed: this.parseJsonColumn(row.files_changed),
+                        similarity: 0.0,
+                    });
+                }
+            }
+            const finalResults = [];
+            for (const r of results) {
+                if (fullNodeMap.has(r.id)) {
+                    const node = fullNodeMap.get(r.id);
+                    const normEnergy = normalizeActivationEnergy(r.activationEnergy);
+                    node.activationScore = normEnergy;
+                    node.rawActivationEnergy = r.activationEnergy;
+                    // Hybrid blend: 70% original match relevance, 30% structural energy
+                    node.hybridScore = (node.similarity * 0.7) + (normEnergy * 0.3);
+                    finalResults.push(node);
+                }
+            }
+            return finalResults.sort((a, b) => (b.hybridScore || 0) - (a.hybridScore || 0));
+        }
+        catch (err) {
+            debugLog(`[SqliteStorage] applySynapse failed (non-fatal, returning original anchors): ${err instanceof Error ? err.message : String(err)}`);
+            return anchors;
+        }
+    }
     // ─── Compaction ────────────────────────────────────────────
     async getCompactionCandidates(threshold, keepRecent, userId) {
         const result = await this.db.execute({
@@ -2564,6 +2621,27 @@ export class SqliteStorage {
         });
         return (result.rowsAffected ?? 0) > 0;
     }
+    async getLinksForNodes(nodeIds, userId) {
+        if (nodeIds.length === 0)
+            return [];
+        const placeholders = nodeIds.map(() => "?").join(", ");
+        const sql = `
+      SELECT m.source_id, m.target_id, m.strength
+      FROM memory_links m
+      JOIN session_ledger s ON m.source_id = s.id
+      JOIN session_ledger t ON m.target_id = t.id
+      WHERE (m.source_id IN (${placeholders}) OR m.target_id IN (${placeholders}))
+        AND s.user_id = ? AND s.deleted_at IS NULL AND s.archived_at IS NULL
+        AND t.user_id = ? AND t.deleted_at IS NULL AND t.archived_at IS NULL
+    `;
+        const args = [...nodeIds, ...nodeIds, userId, userId];
+        const result = await this.db.execute({ sql, args });
+        return result.rows.map(r => ({
+            source_id: r.source_id,
+            target_id: r.target_id,
+            strength: r.strength,
+        }));
+    }
     async getLinksFrom(sourceId, userId, minStrength = 0.0, limit = 25) {
         // JOIN session_ledger to enforce:
         //   1. Tenant isolation (target.user_id = userId)

package/dist/storage/supabase.js

@@ -15,7 +15,7 @@
 import { supabasePost, supabaseGet, supabaseRpc, supabasePatch, supabaseDelete, } from "../utils/supabaseApi.js";
 import { gzipSync, gunzipSync } from "node:zlib";
 import { debugLog } from "../utils/logger.js";
-import { PRISM_USER_ID } from "../config.js";
+import { PRISM_USER_ID, PRISM_SYNAPSE_ENABLED, PRISM_SYNAPSE_ITERATIONS, PRISM_SYNAPSE_SPREAD_FACTOR, PRISM_SYNAPSE_LATERAL_INHIBITION, PRISM_SYNAPSE_SOFT_CAP, } from "../config.js";
 import { getSetting as cfgGet, setSetting as cfgSet, getAllSettings as cfgGetAll } from "./configStorage.js";
 import { runAutoMigrations } from "./supabaseMigrations.js";
 import { SafetyController } from "../darkfactory/safetyController.js";
@@ -221,6 +221,20 @@ export class SupabaseStorage {
             if (!data || !data.results || data.count === 0) {
                 return null;
             }
+            // v8.0: Apply Synapse graph enrichment if activation is enabled
+            if (params.activation?.enabled && Array.isArray(data.results) && data.results.length > 0) {
+                const mappedAnchors = data.results.map((r) => ({
+                    id: r.id,
+                    project: r.project,
+                    summary: r.summary,
+                    similarity: 1.0, // FTS matches treated as 1.0 similarity
+                    session_date: r.session_date,
+                    decisions: Array.isArray(r.decisions) ? r.decisions : [],
+                    files_changed: Array.isArray(r.files_changed) ? r.files_changed : [],
+                }));
+                const activated = await this.applySynapse(mappedAnchors, params.activation, params.userId);
+                return { count: activated.length, results: activated };
+            }
             return data;
         }
         catch (e) {
@@ -254,7 +268,11 @@ export class SupabaseStorage {
                 p_user_id: params.userId,
                 p_role: params.role || null,
             });
-            return Array.isArray(result) ? result : [];
+            const baseResults = Array.isArray(result) ? result : [];
+            if (params.activation?.enabled && baseResults.length > 0) {
+                return this.applySynapse(baseResults, params.activation, params.userId);
+            }
+            return baseResults;
         }
         catch (tier1Err) {
             // ─── TIER 2 FALLBACK: TurboQuant JS-side scoring ─────────────────
@@ -305,7 +323,11 @@ export class SupabaseStorage {
                 scored.sort((a, b) => b.similarity - a.similarity);
                 debugLog(`[SupabaseStorage] Tier-2 TurboQuant fallback: scored ${rows.length} entries, ` +
                     `${scored.length} above threshold`);
-                return scored.slice(0, params.limit);
+                const tier2Results = scored.slice(0, params.limit);
+                if (params.activation?.enabled && tier2Results.length > 0) {
+                    return this.applySynapse(tier2Results, params.activation, params.userId);
+                }
+                return tier2Results;
             }
             catch (tier2Err) {
                 // Both tiers failed — return empty; caller falls through to FTS5
@@ -317,6 +339,79 @@ export class SupabaseStorage {
             }
         }
     }
+    // ─── Synapse Engine Integration (v8.0) ────────────────────────
+    //
+    // Storage-agnostic multi-hop activation enrichment.
+    // Mirrors SqliteStorage.applySynapse() — the Synapse engine itself
+    // is pure (zero I/O), receiving link data via the getLinksForNodes
+    // callback. Missing node metadata is fetched via Supabase REST.
+    async applySynapse(anchors, options, userId) {
+        if (!PRISM_SYNAPSE_ENABLED || !options.enabled || anchors.length === 0)
+            return anchors;
+        try {
+            const { propagateActivation, normalizeActivationEnergy } = await import("../memory/synapseEngine.js");
+            const { recordSynapseTelemetry } = await import("../observability/graphMetrics.js");
+            const anchorMap = new Map();
+            for (const a of anchors)
+                anchorMap.set(a.id, a.similarity ?? 1.0);
+            const { results, telemetry } = await propagateActivation(anchorMap, async (nodeIds) => this.getLinksForNodes(nodeIds, userId), {
+                iterations: options.iterations ?? PRISM_SYNAPSE_ITERATIONS,
+                spreadFactor: options.spreadFactor ?? PRISM_SYNAPSE_SPREAD_FACTOR,
+                lateralInhibition: options.lateralInhibition ?? PRISM_SYNAPSE_LATERAL_INHIBITION,
+                softCap: PRISM_SYNAPSE_SOFT_CAP,
+            });
+            recordSynapseTelemetry(telemetry);
+            // Build node lookup from anchor results
+            const fullNodeMap = new Map();
+            for (const a of anchors)
+                fullNodeMap.set(a.id, a);
+            // Fetch metadata for nodes discovered by propagation (not in original anchors)
+            const finalIds = results.map(r => r.id);
+            const missingIds = finalIds.filter(id => !fullNodeMap.has(id));
+            if (missingIds.length > 0) {
+                try {
+                    const rows = await supabaseGet("session_ledger", {
+                        id: `in.(${missingIds.join(",")})`,
+                        user_id: `eq.${userId}`,
+                        deleted_at: "is.null",
+                        select: "id,project,summary,session_date,decisions,files_changed",
+                    });
+                    for (const row of (Array.isArray(rows) ? rows : [])) {
+                        fullNodeMap.set(row.id, {
+                            id: row.id,
+                            project: row.project,
+                            summary: row.summary,
+                            session_date: row.session_date,
+                            decisions: Array.isArray(row.decisions) ? row.decisions : [],
+                            files_changed: Array.isArray(row.files_changed) ? row.files_changed : [],
+                            similarity: 0.0,
+                        });
+                    }
+                }
+                catch (e) {
+                    debugLog(`[SupabaseStorage] applySynapse: failed to fetch missing nodes: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            // Compute hybrid scores and build final result set
+            const finalResults = [];
+            for (const r of results) {
+                if (fullNodeMap.has(r.id)) {
+                    const node = fullNodeMap.get(r.id);
+                    const normEnergy = normalizeActivationEnergy(r.activationEnergy);
+                    node.activationScore = normEnergy;
+                    node.rawActivationEnergy = r.activationEnergy;
+                    // Hybrid blend: 70% original match relevance, 30% structural energy
+                    node.hybridScore = (node.similarity * 0.7) + (normEnergy * 0.3);
+                    finalResults.push(node);
+                }
+            }
+            return finalResults.sort((a, b) => (b.hybridScore || 0) - (a.hybridScore || 0));
+        }
+        catch (err) {
+            debugLog(`[SupabaseStorage] applySynapse failed (non-fatal, returning original anchors): ${err instanceof Error ? err.message : String(err)}`);
+            return anchors;
+        }
+    }
     // ─── Compaction ────────────────────────────────────────────
     async getCompactionCandidates(threshold, keepRecent, userId) {
         try {
@@ -994,6 +1089,26 @@ export class SupabaseStorage {
             return [];
         }
     }
+    async getLinksForNodes(nodeIds, userId) {
+        if (!nodeIds || nodeIds.length === 0)
+            return [];
+        try {
+            const result = await supabaseRpc("prism_get_links_for_nodes", {
+                p_node_ids: nodeIds,
+                p_user_id: userId
+            });
+            const rows = Array.isArray(result) ? result : [];
+            return rows.map((r) => ({
+                source_id: r.source_id,
+                target_id: r.target_id,
+                strength: r.strength
+            }));
+        }
+        catch (e) {
+            debugLog("[SupabaseStorage] getLinksForNodes failed: " + e.message);
+            return [];
+        }
+    }
     async countLinks(entryId, linkType) {
         try {
             const query = { source_id: `eq.${entryId}` };

package/dist/tools/graphHandlers.js

@@ -51,7 +51,7 @@ const activeCompactions = new Set();
  * After saving, generates an embedding vector for the entry via fire-and-forget.
  */
 import { computeEffectiveImportance, recordMemoryAccess } from "../utils/cognitiveMemory.js";
-import { baseLevelActivation, candidateScopedSpreadingActivation, compositeRetrievalScore, } from "../utils/actrActivation.js";
+import { baseLevelActivation, compositeRetrievalScore, } from "../utils/actrActivation.js";
 import { PRISM_ACTR_ENABLED, PRISM_ACTR_DECAY, PRISM_ACTR_WEIGHT_SIMILARITY, PRISM_ACTR_WEIGHT_ACTIVATION, PRISM_ACTR_SIGMOID_MIDPOINT, PRISM_ACTR_SIGMOID_STEEPNESS, PRISM_ACTR_MAX_ACCESSES_PER_ENTRY, } from "../config.js";
 import { HdcStateMachine } from "../sdm/stateMachine.js";
 import { ConceptDictionary } from "../sdm/conceptDictionary.js";
@@ -419,21 +419,8 @@ export async function sessionSearchMemoryHandler(args) {
             try {
                 // Step A: Bulk-fetch access logs for all candidate IDs
                 const accessLogMap = await storage.getAccessLog(resultIds, PRISM_ACTR_MAX_ACCESSES_PER_ENTRY);
-                // Step B: Fetch outbound links for spreading activation
-                const candidateIdSet = new Set(resultIds);
-                const linksMap = new Map();
-                for (const id of resultIds) {
-                    try {
-                        const links = await storage.getLinksFrom(id, PRISM_USER_ID, 0.0, 20);
-                        linksMap.set(id, links.map((l) => ({
-                            target_id: l.target_id,
-                            strength: l.strength ?? 1.0,
-                        })));
-                    }
-                    catch {
-                        linksMap.set(id, []);
-                    }
-                }
+                // Step B: Removed. Synapse Engine (v8.0) handles multi-hop propagation 
+                // at the storage layer when activation is enabled.
                 // Step C: Compute activation for each result and re-rank
                 actrMetrics = { baseLevels: [], spreadings: [], sigmoids: [], composites: [] };
                 for (const r of results) {
@@ -450,9 +437,9 @@ export async function sessionSearchMemoryHandler(args) {
                     // They should decay 50% slower than raw episodic chatter to retain long-term context.
                     const decayRate = r.is_rollup ? PRISM_ACTR_DECAY * 0.5 : PRISM_ACTR_DECAY;
                     const Bi = baseLevelActivation(timestamps, now, decayRate);
-                    // S_i: Candidate-scoped spreading activation
-                    const outboundLinks = linksMap.get(id) || [];
-                    const Si = candidateScopedSpreadingActivation(outboundLinks, candidateIdSet);
+                    // S_i: Structural activation energy from Synapse logic 
+                    // (computed during applySynapse in storage layer)
+                    const Si = (typeof r.rawActivationEnergy === 'number') ? r.rawActivationEnergy : 0;
                     // Composite retrieval score
                     const composite = compositeRetrievalScore(typeof r.similarity === "number" ? r.similarity : 0, Bi + Si, PRISM_ACTR_WEIGHT_SIMILARITY, PRISM_ACTR_WEIGHT_ACTIVATION, PRISM_ACTR_SIGMOID_MIDPOINT, PRISM_ACTR_SIGMOID_STEEPNESS);
                     // Attach to result for re-sorting and display

package/dist/utils/actrActivation.js

@@ -111,6 +111,8 @@ export function baseLevelActivation(accessTimestamps, now, decayRate = ACT_R_DEF
  *
  * W = 1 / |candidateIds| (uniform attention weight across candidates)
  *
+ * @deprecated Use Synapse engine (v8.0) at the storage layer instead via `applySynapse()`.
+ *
  * @param outboundLinks - All outbound links from this memory entry
  * @param candidateIds - Set of entry IDs in the current search result set
  * @returns Spreading activation value (0 to ~1.0 range)

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

@@ -0,0 +1,153 @@
+/**
+ * Ollama Adapter (v1.0 — nomic-embed-text)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * PURPOSE:
+ *   Implements LLMProvider using Ollama's native /api/embed REST endpoint for
+ *   fully local, zero-cost text embeddings. No API key required — Ollama runs
+ *   on localhost.
+ *
+ * TEXT GENERATION:
+ *   This adapter is embeddings-only. generateText() throws an explicit error.
+ *   Set text_provider separately (anthropic, openai, or gemini).
+ *
+ * EMBEDDING DIMENSION PARITY (768 dims):
+ *   Prism's SQLite (sqlite-vec) and Supabase (pgvector) schemas define
+ *   embedding columns as EXACTLY 768 dimensions.
+ *
+ *   nomic-embed-text natively outputs 768 dims — zero truncation needed.
+ *   It is the recommended default local model for Prism.
+ *
+ * SUPPORTED MODELS (all confirmed 768-dim via Ollama):
+ *   nomic-embed-text     — 768 dims, 274MB, best quality/size trade-off ✅ DEFAULT
+ *   nomic-embed-text:v1.5 — 768 dims, 274MB, same (stable alias)
+ *
+ *   Models to AVOID with this adapter (wrong dim count):
+ *   mxbai-embed-large    — 1024 dims ❌  (use OpenAIAdapter instead)
+ *   all-minilm           — 384 dims  ❌
+ *   snowflake-arctic-embed — varies  ❌
+ *
+ * BATCH EMBEDDINGS:
+ *   Uses /api/embed (plural) which is the official Ollama batch endpoint
+ *   introduced in Ollama ≥ 0.3.0. Falls back gracefully for older versions.
+ *
+ * CONFIG KEYS (Prism dashboard "AI Providers" tab OR environment variables):
+ *   ollama_base_url   — Base URL of Ollama server (default: http://localhost:11434)
+ *   ollama_model      — Embedding model (default: nomic-embed-text)
+ *
+ * USAGE:
+ *   In the Prism dashboard, set:
+ *     embedding_provider = ollama
+ *   Optionally set ollama_base_url and ollama_model to override defaults.
+ *
+ * API REFERENCE:
+ *   https://github.com/ollama/ollama/blob/main/docs/api.md#generate-embeddings
+ */
+import { getSettingSync } from "../../../storage/configStorage.js";
+import { debugLog } from "../../logger.js";
+// ─── Constants ────────────────────────────────────────────────────────────────
+// Must match Prism's DB schema (sqlite-vec and pgvector column sizes).
+const EMBEDDING_DIMS = 768;
+// Generous character cap — nomic-embed-text has an 8192-token context window.
+const MAX_EMBEDDING_CHARS = 8000;
+const DEFAULT_BASE_URL = "http://localhost:11434";
+const DEFAULT_MODEL = "nomic-embed-text";
+// Connection retry settings — handles the common "forgot to start Ollama" race.
+const MAX_RETRIES = 2;
+const RETRY_DELAY_MS = 500;
+// ─── Adapter ─────────────────────────────────────────────────────────────────
+export class OllamaAdapter {
+    baseUrl;
+    model;
+    constructor() {
+        this.baseUrl = getSettingSync("ollama_base_url", DEFAULT_BASE_URL).replace(/\/$/, "");
+        this.model = getSettingSync("ollama_model", DEFAULT_MODEL);
+        debugLog(`[OllamaAdapter] Initialized — baseUrl=${this.baseUrl}, model=${this.model}`);
+    }
+    // ─── Text Generation (Not Supported) ────────────────────────────────────
+    async generateText(_prompt, _systemInstruction) {
+        throw new Error("OllamaAdapter does not support text generation. " +
+            "Set text_provider to 'anthropic', 'openai', or 'gemini' in the dashboard.");
+    }
+    // ─── Batch Embedding Generation ─────────────────────────────────────────
+    async generateEmbeddings(texts) {
+        if (!texts || texts.length === 0)
+            return [];
+        const model = this.model;
+        // Word-safe truncation — consistent with Voyage and OpenAI adapters.
+        const truncatedTexts = texts.map(text => {
+            if (text.length > MAX_EMBEDDING_CHARS) {
+                const cut = text.slice(0, MAX_EMBEDDING_CHARS);
+                const lastSpace = cut.lastIndexOf(" ");
+                return lastSpace > 0 ? cut.slice(0, lastSpace) : cut;
+            }
+            return text;
+        });
+        debugLog(`[OllamaAdapter] generateEmbeddings — model=${model}, count=${truncatedTexts.length}`);
+        // Retry loop — catches ECONNREFUSED when Ollama service hasn't started yet.
+        let response;
+        let lastError = null;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                response = await fetch(`${this.baseUrl}/api/embed`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ model, input: truncatedTexts }),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "unknown error");
+                    throw new Error(`[OllamaAdapter] /api/embed request failed — status=${response.status}: ${errorText}. ` +
+                        `Make sure Ollama is running (ollama serve) and '${model}' has been pulled (ollama pull ${model}).`);
+                }
+                // Success — break out of retry loop.
+                lastError = null;
+                break;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                const isNetworkError = lastError.message.includes("ECONNREFUSED") ||
+                    lastError.message.includes("fetch failed") ||
+                    lastError.message.includes("ECONNRESET");
+                if (isNetworkError && attempt < MAX_RETRIES) {
+                    debugLog(`[OllamaAdapter] Connection failed (attempt ${attempt + 1}/${MAX_RETRIES + 1}): ` +
+                        `${lastError.message.substring(0, 80)}. Retrying in ${RETRY_DELAY_MS}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+                    continue;
+                }
+                throw lastError;
+            }
+        }
+        if (lastError)
+            throw lastError;
+        const data = (await response.json());
+        const embeddings = data?.embeddings;
+        if (!Array.isArray(embeddings) || embeddings.length === 0) {
+            throw new Error(`[OllamaAdapter] Empty embeddings response from model '${model}'.`);
+        }
+        if (embeddings.length !== texts.length) {
+            throw new Error(`[OllamaAdapter] Response length mismatch — expected ${texts.length}, got ${embeddings.length}.`);
+        }
+        // Validate dimensions and slice if model returned > 768 (shouldn't happen
+        // with nomic-embed-text but guards against model swaps).
+        return embeddings.map((emb, i) => {
+            if (emb.length > EMBEDDING_DIMS) {
+                debugLog(`[OllamaAdapter] Embedding[${i}] has ${emb.length} dims — truncating to ${EMBEDDING_DIMS}. ` +
+                    `Consider using a model that natively outputs ${EMBEDDING_DIMS} dims (e.g. nomic-embed-text).`);
+                return emb.slice(0, EMBEDDING_DIMS);
+            }
+            if (emb.length !== EMBEDDING_DIMS) {
+                throw new Error(`[OllamaAdapter] Dimension mismatch at index ${i}: expected ${EMBEDDING_DIMS}, ` +
+                    `got ${emb.length}. Model '${model}' is not compatible with Prism's 768-dim schema. ` +
+                    `Use nomic-embed-text which natively outputs 768 dims.`);
+            }
+            return emb;
+        });
+    }
+    // ─── Single Embedding (delegates to batch) ───────────────────────────────
+    async generateEmbedding(text) {
+        if (!text || !text.trim()) {
+            throw new Error("[OllamaAdapter] generateEmbedding called with empty text.");
+        }
+        const results = await this.generateEmbeddings([text]);
+        return results[0];
+    }
+}

package/dist/utils/llm/factory.js

@@ -1,5 +1,5 @@
 /**
- * LLM Provider Factory (v4.5 — Voyage AI Embedding Support)
+ * LLM Provider Factory (v4.6 — Ollama Local Embedding Support)
  * ─────────────────────────────────────────────────────────────────────────────
  * PURPOSE:
  *   Single point of resolution for the active LLMProvider.
@@ -11,7 +11,7 @@
  *   Two independent settings control text and embedding routing:
  *
  *   text_provider      — "gemini" (default) | "openai" | "anthropic"
- *   embedding_provider — "auto" (default)   | "gemini" | "openai" | "voyage"
+ *   embedding_provider — "auto" (default)   | "gemini" | "openai" | "voyage" | "ollama"
  *
  *   When embedding_provider = "auto":
  *     * If text_provider is gemini or openai → use same provider for embeddings
@@ -24,8 +24,10 @@
  *   text_provider=openai,    embedding_provider=auto   → OpenAI+OpenAI
  *   text_provider=anthropic, embedding_provider=auto   → Claude+Gemini (auto-bridge)
  *   text_provider=anthropic, embedding_provider=voyage → Claude+Voyage (Anthropic-recommended)
- *   text_provider=anthropic, embedding_provider=openai → Claude+Ollama (cost-optimized)
+ *   text_provider=anthropic, embedding_provider=openai → Claude+OpenAI cloud embeddings
+ *   text_provider=anthropic, embedding_provider=ollama → Claude+Ollama (fully local, zero-cost)
  *   text_provider=gemini,    embedding_provider=voyage → Gemini+Voyage (mixed)
+ *   text_provider=gemini,    embedding_provider=ollama → Gemini+Ollama (hybrid cloud/local)
  *
  * SINGLETON + GRACEFUL DEGRADATION:
  *   Same as before — instance cached per process, errors fall back to Gemini.
@@ -44,6 +46,7 @@ import { GeminiAdapter } from "./adapters/gemini.js";
 import { OpenAIAdapter } from "./adapters/openai.js";
 import { AnthropicAdapter } from "./adapters/anthropic.js";
 import { VoyageAdapter } from "./adapters/voyage.js";
+import { OllamaAdapter } from "./adapters/ollama.js";
 import { TracingLLMProvider } from "./adapters/traced.js";
 // Module-level singleton — one composed provider per MCP server process.
 let providerInstance = null;
@@ -62,10 +65,12 @@ function buildEmbeddingAdapter(type) {
     // Note: "anthropic" is intentionally absent from this switch.
     // Anthropic has no embedding API, so it can never be an embedding provider.
     // The factory resolves "auto" away from "anthropic" before calling this.
-    // For Anthropic text users, "voyage" is the Anthropic-recommended pairing.
+    // For Anthropic text users, "voyage" is the recommended pairing;
+    // "ollama" is the fully local zero-cost alternative.
     switch (type) {
         case "openai": return new OpenAIAdapter();
         case "voyage": return new VoyageAdapter();
+        case "ollama": return new OllamaAdapter();
         case "gemini":
         default: return new GeminiAdapter();
     }
@@ -90,10 +95,15 @@ export function getLLMProvider() {
     let embedType = getSettingSync("embedding_provider", "auto");
     if (embedType === "auto") {
         if (process.env.VOYAGE_API_KEY) {
-            // If Voyage is available, use it as the default embedding provider
-            // since voyage-code-3 strongly outperforms general embeddings on code contexts.
+            // Voyage takes first priority when available — voyage-code-3 strongly
+            // outperforms general embeddings on code contexts.
             embedType = "voyage";
         }
+        else if (process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL) {
+            // Ollama is second priority: fully local, zero-cost, zero-latency.
+            // Activated when OLLAMA_HOST or OLLAMA_BASE_URL env var is set.
+            embedType = "ollama";
+        }
         else {
             // Anthropic has no embedding API — auto-bridge to Gemini.
             // For all other text providers, use the same provider for embeddings.
@@ -101,9 +111,9 @@ export function getLLMProvider() {
             if (textType === "anthropic") {
                 console.error("[LLMFactory] text_provider=anthropic with embedding_provider=auto: " +
                     "routing embeddings to GeminiAdapter (Anthropic has no native embedding API). " +
-                    "For the Anthropic-recommended pairing, set embedding_provider=voyage in the dashboard " +
-                    "(voyage-code-3 supports 768-dim output via MRL). " +
-                    "Alternatively, set embedding_provider=openai to use Ollama/OpenAI.");
+                    "For the Anthropic-recommended pairing, set embedding_provider=voyage in the dashboard. " +
+                    "For a fully local, zero-cost option, set embedding_provider=ollama " +
+                    "(requires 'ollama pull nomic-embed-text').");
             }
         }
     }

package/dist/utils/llm/provider.js

@@ -16,6 +16,8 @@
  *   - gemini.ts    → Google Gemini (default; all methods including VLM)
  *   - openai.ts    → OpenAI Cloud + Ollama + LM Studio + vLLM
  *   - anthropic.ts → Anthropic Claude (VLM supported; embeddings unsupported)
+ *   - voyage.ts    → Voyage AI (embeddings only; Anthropic-recommended pairing)
+ *   - ollama.ts    → Ollama native /api/embed (embeddings only; fully local, zero-cost)
  *
  * FACTORY RESOLUTION:
  *   Never instantiate adapters directly. Always call:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "7.8.7",
+  "version": "8.0.0",
   "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",