prism-mcp-server 7.8.8 → 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/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/package.json

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