prism-mcp-server 7.7.1 → 7.8.0

package/README.md

@@ -10,9 +10,9 @@
 
 ![Prism Mind Palace Dashboard](docs/mind-palace-dashboard.png)
 
-**Your AI agent forgets everything between sessions. Prism fixes that.**
+**Your AI agent forgets everything between sessions. Prism fixes that — then teaches it to think.**
 
-One command. Persistent memory. Local-first by default. Optional cloud power-ups.
+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.**
 
 ```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)
+- [Cognitive Architecture (v7.8)](#-cognitive-architecture-v78)
 - [Data Privacy & Egress](#data-privacy--egress)
 - [Use Cases](#use-cases)
 - [What's New](#whats-new)
@@ -45,15 +46,17 @@ Works with **Claude Desktop · Claude Code · Cursor · Windsurf · Cline · Gem
 
 Every time you start a new conversation with an AI coding assistant, it starts from scratch. You re-explain your architecture, re-describe your decisions, re-list your TODOs. Hours of context — gone.
 
-**Prism gives your agent a brain that persists.** Save what matters at the end of each session. Load it back instantly on the next one. Your agent remembers what it did, what it learned, and what's left to do.
+**Prism gives your agent a brain that persists — and then teaches it to reason.** Save what matters at the end of each session. Load it back instantly on the next one. But Prism goes far beyond storage: it consolidates raw experience into lasting principles, traverses causal chains to surface root causes, and knows when to say *"I don't know."*
 
-> 📌 **Terminology:** Throughout this doc, **"Prism"** refers to the MCP server and storage engine. **"Mind Palace"** refers to the visual dashboard UI at `localhost:3000` — your window into the agent's brain. They work together; the dashboard is optional.
+> 📌 **Terminology:** Throughout this doc, **"Prism"** refers to the MCP server and cognitive memory engine. **"Mind Palace"** refers to the visual dashboard UI at `localhost:3000` — your window into the agent's brain. They work together; the dashboard is optional.
 
-Prism has two pillars:
+Prism has three pillars:
 
-1. **🧠 Persistent Memory** — Memories are ranked like a human brain: recently and frequently accessed context surfaces first, while stale context fades naturally. The result is retrieval quality that no flat vector search can match. *(See [Scientific Foundation](#-scientific-foundation) for the ACT-R math.)*
+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. **🏭 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).)*
+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).)*
+
+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).)*
 
 ---
 
@@ -456,6 +459,71 @@ When you trigger a Dark Factory pipeline, Prism doesn't just run your task — i
 
 ---
 
+## 🧠 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.*
+
+Standard RAG (Retrieval-Augmented Generation) is now a commodity. Everyone has vector search. What turns a memory *storage* system into a memory *reasoning* system is the cognitive layer between storage and retrieval. Here is what Prism v7.8 builds on top of the vector foundation:
+
+### 1. The Agent Actually Learns (Episodic → Semantic Consolidation)
+
+| | Standard RAG | Prism v7.8 |
+|---|---|---|
+| **Memory** | Giant, flat transcript of past events | Dual-memory: Episodic events + Semantic rules |
+| **Recall** | Re-reads everything linearly | Retrieves distilled principles instantly |
+| **Learning** | None — every session starts cold | Hebbian: confidence increases with repeated reinforcement |
+
+**How it works:** When Prism compacts session history, it doesn't just summarize text — it extracts *principles*. Raw event logs ("We deployed v2.3 and the auth service crashed because the JWT secret was rotated") consolidate into a semantic rule ("JWT secrets must be rotated before deployment, not during"). These rules live in a dedicated `semantic_knowledge` table with `confidence` scores that increase every time the pattern is observed. **Your agent doesn't just remember what it did; it learns *how the world works* over time.** This is true Hebbian learning: neurons that fire together wire together.
+
+### 2. "Train of Thought" Reasoning (Spreading Activation & Causality)
+
+| | Standard RAG | Prism v7.8 |
+|---|---|---|
+| **Search** | Cosine similarity to the query | Multi-hop graph traversal with lateral inhibition |
+| **Scope** | Only finds things that *look like* the prompt | Follows causal chains across memories |
+| **Root cause** | Missed entirely | Surfaced via `caused_by` / `led_to` edges |
+
+**How it works:** When compacting memories, Prism extracts causal links (`caused_by`, `led_to`) and persists them as edges in the knowledge graph. At retrieval time, ACT-R spreading activation propagates through these edges with a damped fan effect (`1 / ln(fan + e)`) to prevent hub-flooding, lateral inhibition to suppress noise, and configurable hop depth. If you search for "Error X", the engine traverses the graph and brings back "Workaround Y" → "Architecture Decision Z" — a literal train of thought instead of a static search result.
+
+```
+  Query: "Why does the API timeout?"
+                    │
+      ┌─────────────┼─────────────┐
+      ▼             ▼             ▼
+  [Memory: API     [Memory:      [Memory:       
+   timeout error]   DB pool       rate limiter
+                    exhaustion]   misconfigured]
+      │                │
+      ▼                ▼
+  [Memory:         [Memory:
+   caused_by →      led_to →
+   connection       connection
+   leak in v2.1]    pool patch
+                    in v2.2]
+```
+
+### 3. Self-Awareness & The End of Hallucinations (The Rejection Gate)
+
+| | Standard RAG | Prism v7.8 |
+|---|---|---|
+| **Bad query** | Returns top-5 garbage results | Returns `rejected: true` with reason |
+| **Confidence** | Always 100% confident (even when wrong) | Measures gap-distance and entropy |
+| **Hallucination risk** | High — LLM gets garbage context | Low — LLM told "you don't know" |
+
+**How it works:** The **Uncertainty-Aware Rejection Gate** operates on two signals: *similarity floor* (is the best match even remotely relevant?) and *gap distance* (is there meaningful separation between the top results, or are they all equally mediocre?). When both signals indicate low confidence, Prism returns a structured rejection — telling the LLM "I searched my memory, and I confidently do not know the answer" — instead of feeding it garbage context that causes hallucinations. In the current LLM landscape, **an agent that knows its own boundaries is a massive competitive advantage.**
+
+### 4. Block Amnesia Solved (Dynamic Fast Weight Decay)
+
+| | Standard RAG | Prism v7.8 |
+|---|---|---|
+| **Decay** | Uniform (everything fades equally) | Dual-rate: episodic fades fast, semantic persists |
+| **Core knowledge** | Forgotten over time | Permanently anchored via `is_rollup` flag |
+| **Personality drift** | Common in long-lived agents | Prevented by Long-Term Context anchors |
+
+**How it works:** Most memory systems decay everything at the same rate, meaning agents eventually forget their core system instructions as time passes. Prism applies ACT-R base-level activation decay (`B_i = ln(Σ t_j^(-d))`) with a **50% slower decay rate for semantic rollup nodes** (`ageModifier = 0.5` for `is_rollup` entries). The agent will naturally forget what it ate for breakfast (raw episodic chatter), but it will permanently remember its core personality, project rules, and hard-won architectural decisions. The result: Long-Term Context anchors that survive indefinitely.
+
+---
+
 ## 🔒 Data Privacy & Egress
 
 **Where is my data stored?**
@@ -623,8 +691,10 @@ The Generator strips the `console.log`, resubmits, and the next `EVALUATE` retur
 
 ## 🆕 What's New
 
-> **Current release: v7.5.0**
+> **Current release: v7.8.0 — Cognitive Architecture**
 
+- 🧠 **v7.8.0 — Cognitive Architecture:** The biggest leap forward yet. Moved beyond flat vector search into a true cognitive architecture inspired by human brain mechanics. Episodic-to-Semantic memory consolidation (Hebbian learning), ACT-R Spreading Activation with multi-hop causal reasoning, Uncertainty-Aware Rejection Gate (your agent can say "I don't know"), and Dynamic Fast Weight Decay (semantic memories outlive episodic chatter by 2×). **Your agents don't just remember; they learn.** → [Cognitive Architecture](#-cognitive-architecture-v78)
+- 🌐 **v7.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.
 - 🏭 **v7.3.x — Dark Factory + Stability:** Fail-closed 3-gate execution pipeline. Dashboard stability and verification diagnostics.
@@ -635,7 +705,7 @@ The Generator strips the `console.log`, resubmits, and the next `EVALUATE` retur
 
 ## ⚔️ How Prism Compares
 
-Standard memory servers (like Mem0, Zep, or the baseline Anthropic MCP) act as passive filing cabinets — they wait for the LLM to search them. **Prism is an active cognitive architecture.** Designed specifically for the **Model Context Protocol (MCP)**, Prism doesn't just store vectors; it manages the LLM's context window autonomously.
+Standard memory servers (like Mem0, Zep, or the baseline Anthropic MCP) act as passive filing cabinets — they wait for the LLM to search them. **Prism is an active cognitive architecture.** Designed specifically for the **Model Context Protocol (MCP)**, Prism doesn't just store vectors — it consolidates experience into principles, traverses causal graphs for multi-hop reasoning, and rejects queries it can't confidently answer.
 
 ### 📊 Feature-by-Feature Comparison
 
@@ -644,7 +714,7 @@ Standard memory servers (like Mem0, Zep, or the baseline Anthropic MCP) act as p
 | **Primary Interface** | **Native MCP** (Tools, Prompts, Resources) | REST API & Python/TS SDKs | REST API & Python/TS SDKs | Native MCP (Tools only) |
 | **Storage Engine** | **BYO SQLite or Supabase** | Managed Cloud / VectorDBs | Managed Cloud / Postgres | Local SQLite only |
 | **Context Assembly** | **Progressive (Quick/Std/Deep)** | Top-K Semantic Search | Top-K + Temporal Summaries | Basic Entity Search |
-| **Memory Mechanics** | **ACT-R Activation (recency×freq), SDM, HDC** | Basic Vector + Entity | Fading Temporal Graph | None (Infinite growth) |
+| **Memory Mechanics** | **ACT-R Activation, Spreading Activation, Hebbian Consolidation, Rejection Gate** | Basic Vector + Entity | Fading Temporal Graph | None (Infinite growth) |
 | **Multi-Agent Sync** | **CRDT (Add-Wins / LWW)** | Cloud locks | Postgres locks | ❌ None (Data races) |
 | **Data Compression** | **TurboQuant (7x smaller vectors)** | ❌ Standard F32 Vectors | ❌ Standard Vectors | ❌ No Vectors |
 | **Observability** | **OTel Traces + Built-in PWA UI** | Cloud Dashboard | Cloud Dashboard | ❌ None |
@@ -883,7 +953,7 @@ Prism is a **stdio-based MCP server** that manages persistent agent memory. Here
 ```
 ┌──────────────────────────────────────────────────────────┐
 │  MCP Client (Claude Desktop / Cursor / Antigravity)      │
-│                    ↕ stdio (JSON-RPC)                    │
+│                    ↕ stdio / SSE (JSON-RPC)              │
 ├──────────────────────────────────────────────────────────┤
 │  Prism MCP Server                                        │
 │                                                          │
@@ -894,8 +964,17 @@ Prism is a **stdio-based MCP server** that manages persistent agent memory. Here
 │  └──────┬───────┘  └──────────────┘  └────────────────┘  │
 │         ↕                                                │
 │  ┌────────────────────────────────────────────────────┐  │
+│  │  Cognitive Engine (v7.8)                           │  │
+│  │  • ACT-R Spreading Activation (multi-hop)         │  │
+│  │  • Episodic → Semantic Consolidation (Hebbian)    │  │
+│  │  • Uncertainty-Aware Rejection Gate               │  │
+│  │  • Dynamic Fast Weight Decay (dual-rate)          │  │
+│  │  • HDC Cognitive Routing (XOR binding)            │  │
+│  └──────┬─────────────────────────────────────────────┘  │
+│         ↕                                                │
+│  ┌────────────────────────────────────────────────────┐  │
 │  │  Storage Engine                                    │  │
-│  │  Local: SQLite + FTS5 + TurboQuant vectors         │  │
+│  │  Local: SQLite + FTS5 + TurboQuant + semantic_knowledge │
 │  │  Cloud: Supabase + pgvector                        │  │
 │  └────────────────────────────────────────────────────┘  │
 │         ↕                                                │
@@ -924,6 +1003,8 @@ Prism is a **stdio-based MCP server** that manages persistent agent memory. Here
 |-------|-----------|---------|
 | **Session Ledger** | SQLite (append-only) | Immutable audit trail of all agent work |
 | **Handoff State** | SQLite (upsert, versioned) | Live project context with OCC + CRDT merging |
+| **Semantic Knowledge** | SQLite (`semantic_knowledge`) | Hebbian-style distilled rules with confidence scoring |
+| **Memory Links** | SQLite (`memory_links`) | Causal graph edges (`caused_by`, `led_to`, `synthesized_from`) |
 | **Keyword Search** | FTS5 virtual tables | Zero-dependency full-text search |
 | **Semantic Search** | TurboQuant compressed vectors | 10× compressed 768-dim embeddings, three-tier retrieval |
 | **Cloud Sync** | Supabase + pgvector | Optional multi-device/team sync |
@@ -943,7 +1024,7 @@ All platforms benefit from the **server-side fallback** (v5.2.1): if `session_lo
 
 ## 🧬 Scientific Foundation
 
-Prism is evolving from smart session logging toward a **cognitive memory architecture** — grounded in real research, not marketing.
+Prism has evolved from smart session logging into a **cognitive memory architecture** — grounded in real research, not marketing. Every retrieval decision is backed by peer-reviewed models from cognitive psychology, neuroscience, and distributed computing.
 
 | Phase | Feature | Inspired By | Status |
 |-------|---------|-------------|--------|
@@ -962,35 +1043,42 @@ Prism is evolving from smart session logging toward a **cognitive memory archite
 | **v6.1** | Prism-Port Vault Export — Obsidian/Logseq `.zip` with YAML frontmatter & `[[Wikilinks]]` | Data sovereignty, PKM interop | ✅ Shipped |
 | **v6.1** | Cognitive Load & Semantic Search — dynamic graph thinning, search highlights | Contextual working memory | ✅ Shipped |
 | **v6.2** | Synthesize & Prune — automated edge synthesis, graph pruning, SLO observability | Implicit associative memory | ✅ Shipped |
-| **v7.0** | ACT-R Base-Level Activation — `B_i = ln(Σ t_j^(-d))` recency×frequency re-ranking over similarity candidates | Anderson's ACT-R (Adaptive Control of Thought—Rational, ACM 2025) | ✅ Shipped |
+| **v7.0** | ACT-R Base-Level Activation — `B_i = ln(Σ t_j^(-d))` recency×frequency re-ranking over similarity candidates | Anderson's ACT-R (Adaptive Control of Thought—Rational) | ✅ Shipped |
 | **v7.0** | Candidate-Scoped Spreading Activation — `S_i = Σ(W × strength)` bounded to search result set; prevents God-node dominance | Spreading activation networks (Collins & Loftus, 1975) | ✅ Shipped |
 | **v7.0** | Composite Retrieval Scoring — `0.7 × similarity + 0.3 × σ(activation)`; configurable via `PRISM_ACTR_WEIGHT_*` | Hybrid cognitive-neural retrieval models | ✅ Shipped |
 | **v7.0** | AccessLogBuffer — in-memory batch-write buffer with 5s flush; prevents SQLite `SQLITE_BUSY` under parallel agents | Production reliability engineering | ✅ Shipped |
 | **v7.3** | Dark Factory — 3-gate fail-closed EXECUTE pipeline (parse → type → scope) with structured JSON action contract | Industrial safety systems (defense-in-depth, fail-closed valves) | ✅ Shipped |
 | **v7.2** | Verification-first harness — spec-freeze contract, rubric hash lock, multi-layer assertions, CLI `verify` commands | Programmatic verification systems + adversarial validation loops | ✅ Shipped |
 | **v7.4** | Adversarial Evaluation — PLAN_CONTRACT + EVALUATE with isolated generator/evaluator roles, pre-committed rubrics, and evidence-bound findings | Anti-sycophancy research, adversarial ML evaluation frameworks | ✅ Shipped |
-| **v7.5** | Intent Health Dashboard — 3-signal scoring algorithm (staleness, TODO load, decisions), comprehensive XSS hardening (10 vectors), NaN/`Infinity` guards | Proactive monitoring, defense-in-depth security | ✅ Shipped |
+| **v7.5** | Intent Health Dashboard — 3-signal scoring (staleness × TODO × decisions) with NaN guards and score ceiling | Production observability, proactive monitoring | ✅ Shipped |
+| **v7.7** | Cloud-Native SSE Transport — full network-accessible MCP server via Server-Sent Events | Distributed systems, cloud-native architecture | ✅ Shipped |
+| **v7.8** | Episodic→Semantic Consolidation — raw event logs distilled into `semantic_knowledge` rules with confidence scoring and instance tracking | Hebbian learning ("neurons that fire together wire together"), sleep consolidation (neuroscience) | ✅ Shipped |
+| **v7.8** | Multi-Hop Causal Reasoning — spreading activation traverses `caused_by`/`led_to` edges with damped fan effect (`1/ln(fan+e)`) and lateral inhibition | ACT-R spreading activation (Anderson), Collins & Loftus (1975) | ✅ Shipped |
+| **v7.8** | Uncertainty-Aware Rejection Gate — dual-signal (similarity floor + gap distance) safety layer prevents hallucination from low-confidence retrievals | Metacognition research, uncertainty quantification | ✅ Shipped |
+| **v7.8** | Dynamic Fast Weight Decay — `is_rollup` semantic nodes decay 50% slower (`ageModifier = 0.5`) than episodic entries, creating Long-Term Context anchors | ACT-R base-level activation with differential decay rates | ✅ Shipped |
 | **v7.x** | Affect-Tagged Memory — sentiment shapes what gets recalled | Affect-modulated retrieval (neuroscience) | 🔭 Horizon |
 | **v8+** | Zero-Search Retrieval — no index, no ANN, just ask the vector | Holographic Reduced Representations | 🔭 Horizon |
 
-> Informed by LeCun's "Why AI Systems Don't Learn" (Dupoux, LeCun, Malik) and Kanerva's SDM.
+> Informed by Anderson's ACT-R (Adaptive Control of Thought—Rational), Collins & Loftus spreading activation networks (1975), Kanerva's SDM (1988), Hebb's learning rule, and LeCun's "Why AI Systems Don't Learn" (Dupoux, LeCun, Malik).
 
 ---
 
 ## 📦 Milestones & Roadmap
 
-> **Current: v7.5.0** — Intent Health Dashboard + XSS Hardening ([CHANGELOG](CHANGELOG.md))
+> **Current: v7.8.0** — Cognitive Architecture ([CHANGELOG](CHANGELOG.md))
 
 | Release | Headline |
 |---------|----------|
-| **v7.5** | Intent Health scoring + 10 XSS patches |
-| **v7.4** | Adversarial Evaluation (anti-sycophancy) |
-| **v7.3** | Dark Factory fail-closed execution |
-| **v7.2** | Verification Harness |
-| **v7.1** | Task Router |
-| **v7.0** | ACT-R Activation Memory |
-| **v6.5** | HDC Cognitive Routing |
-| **v6.2** | Synthesize & Prune |
+| **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 |
+| **v7.4** | ⚔️ Adversarial Evaluation (anti-sycophancy) |
+| **v7.3** | 🏭 Dark Factory fail-closed execution |
+| **v7.2** | ✅ Verification Harness |
+| **v7.1** | 🚦 Task Router |
+| **v7.0** | 🧬 ACT-R Activation Memory |
+| **v6.5** | 🔮 HDC Cognitive Routing |
+| **v6.2** | 🧩 Synthesize & Prune |
 
 ### Future Tracks
 - **v7.x: Affect-Tagged Memory** — Recall prioritization improves by weighting memories with affective/contextual valence.
@@ -1037,4 +1125,4 @@ MIT
 
 ---
 
-<sub>**Keywords:** MCP server, Model Context Protocol, Claude Desktop memory, persistent session memory, AI agent memory, local-first, SQLite MCP, Mind Palace, time travel, visual memory, VLM image captioning, OpenTelemetry, GDPR, agent telepathy, multi-agent sync, behavioral memory, cursorrules, Ollama MCP, Brave Search MCP, TurboQuant, progressive context loading, knowledge management, LangChain retriever, LangGraph agent</sub>
+<sub>**Keywords:** MCP server, Model Context Protocol, Claude Desktop memory, persistent session memory, AI agent memory, cognitive architecture, ACT-R spreading activation, Hebbian learning, episodic semantic consolidation, multi-hop reasoning, uncertainty rejection gate, local-first, SQLite MCP, Mind Palace, time travel, visual memory, VLM image captioning, OpenTelemetry, GDPR, agent telepathy, multi-agent sync, behavioral memory, cursorrules, Ollama MCP, Brave Search MCP, TurboQuant, progressive context loading, knowledge management, LangChain retriever, LangGraph agent</sub>

package/dist/memory/spreadingActivation.js

@@ -0,0 +1,107 @@
+/**
+ * Apply ACT-R inspired Spreading Activation, Lateral Inhibition, and Fan Effect.
+ * It traverses the `memory_links` table over T iterations starting from the given anchors.
+ */
+export async function applySpreadingActivation(db, anchors, options, userId) {
+    if (!options.enabled || anchors.length === 0)
+        return anchors;
+    const T = options.iterations ?? 3;
+    const S = options.spreadFactor ?? 0.8;
+    const softM = 20; // Soft lateral inhibition during propagation
+    const finalM = options.lateralInhibition ?? 7; // Final hard lateral inhibition
+    // State: current activation score for nodes.
+    let activeNodes = new Map();
+    for (const anchor of anchors) {
+        activeNodes.set(anchor.id, anchor.similarity || 1.0);
+    }
+    for (let t = 0; t < T; t++) {
+        const nextNodes = new Map();
+        // Preserve existing activation: a_i^(t+1) = a_i^(t) + incoming
+        for (const [id, score] of activeNodes.entries()) {
+            nextNodes.set(id, score);
+        }
+        const currentIds = Array.from(activeNodes.keys());
+        if (currentIds.length === 0)
+            break;
+        const placeholders = currentIds.map(() => '?').join(',');
+        // Fetch edges connected to active nodes with LIMIT to prevent explosion on hub nodes.
+        const edgeQuery = `
+      SELECT source_id, target_id, strength
+      FROM memory_links 
+      WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})
+      LIMIT 200
+    `;
+        const edgeArgs = [...currentIds, ...currentIds];
+        const edgeRes = await db.execute({ sql: edgeQuery, args: edgeArgs });
+        // Compute out-degree (Fan Effect) directly from fetched edge rows
+        // instead of a separate SQL round-trip — halves query count per iteration.
+        const fanMap = new Map();
+        for (const row of edgeRes.rows) {
+            const src = row.source_id;
+            if (activeNodes.has(src)) {
+                fanMap.set(src, (fanMap.get(src) || 0) + 1);
+            }
+        }
+        for (const row of edgeRes.rows) {
+            const source = row.source_id;
+            const target = row.target_id;
+            const strength = Number(row.strength);
+            // Forward flow: Source is active, flows to Target
+            if (activeNodes.has(source)) {
+                const fan = fanMap.get(source) || 1;
+                // Dampened fan effect: instead of strict 1/fan, we use 1 / ln(fan + e)
+                const dampedFan = Math.log(fan + Math.E);
+                const flow = S * (strength * activeNodes.get(source) / dampedFan);
+                nextNodes.set(target, (nextNodes.get(target) || 0) + flow);
+            }
+            // Backward flow: Target is active, flows backward to Source with a heavier penalty
+            if (activeNodes.has(target)) {
+                const flow = (S * 0.5) * (strength * activeNodes.get(target));
+                nextNodes.set(source, (nextNodes.get(source) || 0) + flow);
+            }
+        }
+        // Soft lateral inhibition: Keep only top softM candidates to prevent explosion
+        const sorted = Array.from(nextNodes.entries()).sort((a, b) => b[1] - a[1]);
+        activeNodes = new Map(sorted.slice(0, softM));
+    }
+    // Final evaluation
+    const finalIds = Array.from(activeNodes.keys()).slice(0, finalM);
+    const anchorMap = new Map();
+    for (const a of anchors)
+        anchorMap.set(a.id, a);
+    const finalResults = [];
+    const missingIds = finalIds.filter(id => !anchorMap.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 db.execute({ sql: missingQuery, args: [...missingIds, userId] });
+        for (const row of missingRes.rows) {
+            anchorMap.set(row.id, {
+                id: row.id,
+                project: row.project,
+                summary: row.summary,
+                session_date: row.session_date,
+                decisions: row.decisions && typeof row.decisions === 'string' ? JSON.parse(row.decisions) : undefined,
+                files_changed: row.files_changed && typeof row.files_changed === 'string' ? JSON.parse(row.files_changed) : undefined,
+                similarity: 0.0 // Base similarity is 0 since it wasn't matched originally
+            });
+        }
+    }
+    // Compute Hybrid Score and return M nodes
+    for (const id of finalIds) {
+        if (anchorMap.has(id)) {
+            const node = anchorMap.get(id);
+            const activationScore = activeNodes.get(id) || 0;
+            node.activationScore = activationScore;
+            // Hybrid blend: 70% original match relevance, 30% activation structural energy
+            node.hybridScore = (node.similarity * 0.7) + (activationScore * 0.3);
+            finalResults.push(node);
+        }
+    }
+    // Sort descending by Hybrid Score
+    return finalResults.sort((a, b) => (b.hybridScore || 0) - (a.hybridScore || 0));
+}

package/dist/storage/sqlite.js

@@ -516,6 +516,42 @@ export class SqliteStorage {
         vector BLOB NOT NULL
       )
     `);
+        // ─── Phase 4 Migration: Semantic Knowledge Table ──────────────
+        //
+        // REVIEWER NOTE: Created to separate timeless semantic facts from 
+        // chronological episodic ledger events, per Phase 4 consolidation.
+        await this.db.execute(`
+      CREATE TABLE IF NOT EXISTS semantic_knowledge (
+        id TEXT PRIMARY KEY,
+        project TEXT NOT NULL,
+        user_id TEXT NOT NULL DEFAULT '',
+        concept TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        confidence REAL DEFAULT 0.5,
+        instances INTEGER DEFAULT 1,
+        related_entities TEXT DEFAULT '[]',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+        // v7.8 Migration: Rename legacy columns if upgrading from older schema
+        try {
+            await this.db.execute(`ALTER TABLE semantic_knowledge RENAME COLUMN rule TO description`);
+        }
+        catch { /* column already renamed or doesn't exist */ }
+        try {
+            await this.db.execute(`ALTER TABLE semantic_knowledge ADD COLUMN instances INTEGER DEFAULT 1`);
+        }
+        catch { /* column already exists */ }
+        try {
+            await this.db.execute(`ALTER TABLE semantic_knowledge ADD COLUMN related_entities TEXT DEFAULT '[]'`);
+        }
+        catch { /* column already exists */ }
+        try {
+            await this.db.execute(`ALTER TABLE semantic_knowledge ADD COLUMN updated_at TEXT DEFAULT (datetime('now'))`);
+        }
+        catch { /* column already exists */ }
+        await this.db.execute(`CREATE INDEX IF NOT EXISTS idx_semantic_project ON semantic_knowledge(project)`);
         // v6.5 Migration: Add prng_version column if missing
         try {
             await this.db.execute(`ALTER TABLE hdc_dictionary ADD COLUMN prng_version INTEGER DEFAULT 1`);
@@ -1341,6 +1377,21 @@ export class SqliteStorage {
                 last_accessed_at: r.last_accessed_at,
                 relevance: r.relevance,
             }));
+            if (params.activation?.enabled) {
+                // Normalise FTS5 ranks (more negative = better) into positive 0-1 similarity score approximation
+                const mappedAnchors = results.map(r => ({
+                    id: r.id,
+                    project: r.project,
+                    summary: r.summary,
+                    similarity: 1.0 / (1.0 + Math.abs(r.relevance || 0)),
+                    session_date: r.session_date,
+                    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);
+                return { count: activated.length, results: activated };
+            }
             return { count: results.length, results };
         }
         catch (err) {
@@ -1399,6 +1450,21 @@ export class SqliteStorage {
             importance: r.importance,
             last_accessed_at: r.last_accessed_at,
         }));
+        if (params.activation?.enabled) {
+            // Base similarity mapped as 1.0 for LIKE exact/partial matches
+            const mappedAnchors = results.map(r => ({
+                id: r.id,
+                project: r.project,
+                summary: r.summary,
+                similarity: 1.0,
+                session_date: r.session_date,
+                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);
+            return { count: activated.length, results: activated };
+        }
         return { count: results.length, results };
     }
     async searchMemory(params) {
@@ -1424,7 +1490,7 @@ export class SqliteStorage {
             args.push(params.limit);
             const sql = `
         SELECT l.id, l.project, l.summary, l.decisions, l.files_changed,
-               l.session_date, l.created_at,
+               l.session_date, l.created_at, l.is_rollup, l.importance, l.last_accessed_at,
                (1 - vector_distance_cos(l.embedding, vector(?))) AS similarity
         FROM session_ledger l
         WHERE ${conditions.join(" AND ")}
@@ -1433,7 +1499,7 @@ export class SqliteStorage {
       `;
             const result = await this.db.execute({ sql, args });
             // Filter by similarity threshold and format results
-            return result.rows
+            const baseResults = result.rows
                 .filter(r => r.similarity >= params.similarityThreshold)
                 .map(r => ({
                 id: r.id,
@@ -1443,7 +1509,15 @@ export class SqliteStorage {
                 session_date: (r.session_date || r.created_at),
                 decisions: this.parseJsonColumn(r.decisions),
                 files_changed: this.parseJsonColumn(r.files_changed),
+                is_rollup: Boolean(r.is_rollup),
+                importance: r.importance ?? 0,
+                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 baseResults;
         }
         catch (err) {
             // ─── TIER 2 FALLBACK: Asymmetric TurboQuant search in JS ───
@@ -1495,7 +1569,8 @@ export class SqliteStorage {
                 }
                 const fallbackSql = `
           SELECT id, project, summary, decisions, files_changed,
-                 session_date, created_at, embedding_compressed, embedding_turbo_radius
+                 session_date, created_at, is_rollup, importance, last_accessed_at,
+                 embedding_compressed, embedding_turbo_radius
           FROM session_ledger
           WHERE ${fallbackConditions.join(" AND ")}
         `;
@@ -1517,6 +1592,9 @@ export class SqliteStorage {
                                 session_date: (row.session_date || row.created_at),
                                 decisions: this.parseJsonColumn(row.decisions),
                                 files_changed: this.parseJsonColumn(row.files_changed),
+                                is_rollup: Boolean(row.is_rollup),
+                                importance: row.importance ?? 0,
+                                last_accessed_at: row.last_accessed_at || null,
                             });
                         }
                     }
@@ -1526,9 +1604,14 @@ export class SqliteStorage {
                 }
                 // Sort by similarity descending and limit
                 scored.sort((a, b) => b.similarity - a.similarity);
+                const baseResults = scored.slice(0, params.limit);
                 debugLog(`[SqliteStorage] Tier-2 TurboQuant fallback: scored ${fallbackResult.rows.length} entries, ` +
                     `${scored.length} above threshold`);
-                return scored.slice(0, params.limit);
+                if (params.activation?.enabled) {
+                    const { applySpreadingActivation } = await import("../memory/spreadingActivation.js");
+                    return applySpreadingActivation(this.db, baseResults, params.activation, params.userId);
+                }
+                return baseResults;
             }
             catch (fallbackErr) {
                 // Both tiers failed — return empty
@@ -3090,4 +3173,39 @@ export class SqliteStorage {
             override_reason: row.override_reason || undefined
         };
     }
+    // ─── v7.5: Semantic Consolidation ────────────────────────────────
+    async upsertSemanticKnowledge(data) {
+        const existing = await this.db.execute({
+            sql: `SELECT id, instances, confidence FROM semantic_knowledge WHERE project = ? AND concept = ? LIMIT 1`,
+            args: [data.project, data.concept]
+        });
+        if (existing.rows.length > 0) {
+            const row = existing.rows[0];
+            const newConfidence = Math.min(1.0, row.confidence + 0.1);
+            await this.db.execute({
+                sql: `UPDATE semantic_knowledge SET instances = instances + 1, confidence = ?, updated_at = ? WHERE id = ?`,
+                args: [newConfidence, new Date().toISOString(), row.id]
+            });
+            return row.id;
+        }
+        else {
+            const id = crypto.randomUUID();
+            await this.db.execute({
+                sql: `INSERT INTO semantic_knowledge (id, project, user_id, concept, description, confidence, instances, related_entities, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+                args: [
+                    id,
+                    data.project,
+                    data.userId || '',
+                    data.concept,
+                    data.description,
+                    0.5,
+                    1,
+                    JSON.stringify(data.related_entities || []),
+                    new Date().toISOString(),
+                    new Date().toISOString()
+                ]
+            });
+            return id;
+        }
+    }
 }

package/dist/storage/supabase.js

@@ -1440,4 +1440,10 @@ export class SupabaseStorage {
             throw e;
         }
     }
+    // ─── v7.5: Semantic Consolidation ────────────────────────────────
+    async upsertSemanticKnowledge(data) {
+        // For now we just implement graceful degradation/no-op on Supabase until the SQL is deployed.
+        debugLog(`[SupabaseStorage] upsertSemanticKnowledge is not fully implemented in Supabase yet. Skipping for ${data.concept}.`);
+        return crypto.randomUUID();
+    }
 }

package/dist/tools/compactionHandler.js

@@ -20,27 +20,31 @@ export function isCompactLedgerArgs(args) {
 // ─── LLM Summarization ────────────────────────────────────────
 async function summarizeEntries(entries) {
     const llm = getLLMProvider(); // throws if no API key configured
-    const entriesText = entries.map((e, i) => `[${i + 1}] ${e.session_date || "unknown date"}: ${e.summary || "no summary"}\n` +
+    const entriesText = entries.map((e, i) => `[${i + 1}] ID: ${e.id || "N/A"} | Date: ${e.session_date || "unknown date"}: ${e.summary || "no summary"}\n` +
         (e.decisions?.length ? `  Decisions: ${e.decisions.join("; ")}\n` : "") +
         (e.files_changed?.length ? `  Files: ${e.files_changed.join(", ")}\n` : "")).join("\n");
     const prompt = (`You are compressing a session history log for an AI agent's persistent memory.\n\n` +
-        `Analyze these ${entries.length} work sessions and produce THREE sections:\n\n` +
-        `1. SUMMARY (max 300 words): A concise paragraph preserving key decisions, ` +
-        `important file changes, error resolutions, and architecture changes. ` +
-        `Omit routine operations and intermediate debugging steps.\n\n` +
-        `2. PRINCIPLES (1-3 bullet points): Reusable lessons extracted from these sessions. ` +
-        `These should be actionable engineering insights the agent can apply to future work. ` +
-        `Format: "- [principle]"\n\n` +
-        `3. PATTERNS (1-3 bullet points): Recurring behaviors, tools, or workflows observed. ` +
-        `Format: "- [pattern]"\n\n` +
+        `Analyze these ${entries.length} work sessions and output a VALID JSON OBJECT matching this structure:\n` +
+        `{\n` +
+        `  "summary": "Concise paragraph preserving key decisions, important file changes, error resolutions, and architecture changes. Omit routine operations and intermediate debugging steps.",\n` +
+        `  "principles": [\n` +
+        `    { "concept": "Brief concept name", "description": "Reusable lesson extracted from sessions", "related_entities": ["tool", "tech"] }\n` +
+        `  ],\n` +
+        `  "causal_links": [\n` +
+        `    { "source_id": "Session ID that caused it", "target_id": "Session ID that was affected", "relation": "led_to" | "caused_by", "reason": "Explanation" }\n` +
+        `  ]\n` +
+        `}\n\n` +
         `Sessions to analyze:\n${entriesText}\n\n` +
-        `Output format (follow exactly):\n` +
-        `[summary paragraph]\n\n` +
-        `Principles:\n` +
-        `- ...\n\n` +
-        `Patterns:\n` +
-        `- ...`).substring(0, 30000);
-    return llm.generateText(prompt);
+        `Respond ONLY with raw JSON.`).substring(0, 30000);
+    const response = await llm.generateText(prompt);
+    try {
+        const cleanJson = response.replace(/^```json\n?/, "").replace(/\n?```$/, "");
+        return JSON.parse(cleanJson);
+    }
+    catch (err) {
+        debugLog(`[compact_ledger] Failed to parse JSON from LLM: ${err}`);
+        return { summary: response, principles: [], causal_links: [] };
+    }
 }
 // ─── Main Handler ─────────────────────────────────────────────
 export async function compactLedgerHandler(args) {
@@ -126,19 +130,32 @@ export async function compactLedgerHandler(args) {
         for (let i = 0; i < oldEntries.length; i += COMPACTION_CHUNK_SIZE) {
             chunks.push(oldEntries.slice(i, i + COMPACTION_CHUNK_SIZE));
         }
-        let finalSummary;
+        let finalSummaryText;
+        let finalPrinciples = [];
+        let finalCausalLinks = [];
         if (chunks.length === 1) {
-            finalSummary = await summarizeEntries(chunks[0]);
+            const res = await summarizeEntries(chunks[0]);
+            finalSummaryText = typeof res === 'string' ? res : (res.summary || JSON.stringify(res));
+            finalPrinciples = res.principles || [];
+            finalCausalLinks = res.causal_links || [];
         }
         else {
             const chunkSummaries = await Promise.all(chunks.map(chunk => summarizeEntries(chunk)));
+            chunkSummaries.forEach(s => {
+                finalPrinciples.push(...(s.principles || []));
+                finalCausalLinks.push(...(s.causal_links || []));
+            });
             const metaEntries = chunkSummaries.map((s, i) => ({
+                id: `chunk-${i}`,
                 session_date: `chunk ${i + 1}`,
-                summary: s,
+                summary: s.summary,
                 decisions: [],
                 files_changed: [],
             }));
-            finalSummary = await summarizeEntries(metaEntries);
+            const metaRes = await summarizeEntries(metaEntries);
+            finalSummaryText = typeof metaRes === 'string' ? metaRes : (metaRes.summary || JSON.stringify(metaRes));
+            finalPrinciples.push(...(metaRes.principles || []));
+            finalCausalLinks.push(...(metaRes.causal_links || []));
         }
         // Collect all unique keywords from rolled-up entries
         const allKeywords = [...new Set(oldEntries.flatMap((e) => e.keywords || []))];
@@ -148,7 +165,7 @@ export async function compactLedgerHandler(args) {
         const savedRollup = await storage.saveLedger({
             project: proj,
             user_id: PRISM_USER_ID,
-            summary: `[ROLLUP of ${oldEntries.length} sessions] ${finalSummary}`,
+            summary: `[ROLLUP of ${oldEntries.length} sessions] ${finalSummaryText}`,
             keywords: allKeywords,
             files_changed: allFiles,
             decisions: [`Rolled up ${oldEntries.length} sessions on ${new Date().toISOString()}`],
@@ -173,6 +190,48 @@ export async function compactLedgerHandler(args) {
                     debugLog(`[compact_ledger] Failed to create spawned_from link for ${rollupId}: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }));
+            // ── v7.5: Process semantic rules and causal links ──────────
+            for (const principle of finalPrinciples) {
+                if (!principle.concept || !principle.description)
+                    continue;
+                try {
+                    const semanticId = await storage.upsertSemanticKnowledge({
+                        project: proj,
+                        concept: principle.concept,
+                        description: principle.description,
+                        related_entities: principle.related_entities || [],
+                        userId: PRISM_USER_ID,
+                    });
+                    await storage.createLink({
+                        source_id: rollupId,
+                        target_id: semanticId,
+                        link_type: "related_to",
+                        strength: 0.8,
+                        metadata: JSON.stringify({ reason: "derived_principle" })
+                    }, PRISM_USER_ID);
+                }
+                catch (err) {
+                    debugLog(`[compact_ledger] Failed to upsert semantic knowledge: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            for (const link of finalCausalLinks) {
+                if (!link.source_id || !link.target_id || !link.relation)
+                    continue;
+                if (link.source_id.startsWith("chunk-") || link.target_id.startsWith("chunk-"))
+                    continue;
+                try {
+                    await storage.createLink({
+                        source_id: link.source_id,
+                        target_id: link.target_id,
+                        link_type: link.relation,
+                        strength: 0.9,
+                        metadata: JSON.stringify({ reason: link.reason || "causal inference during compaction" })
+                    }, PRISM_USER_ID);
+                }
+                catch (err) {
+                    debugLog(`[compact_ledger] Failed to create causal link: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
         }
         // Step 5: Archive old entries (soft-delete)
         for (const entry of oldEntries) {

package/dist/tools/graphHandlers.js

@@ -63,7 +63,7 @@ export async function knowledgeSearchHandler(args) {
         throw new Error("Invalid arguments for knowledge_search");
     }
     // Phase 1: destructure enable_trace (defaults to false for backward compat)
-    const { project, query, category, limit = 10, enable_trace = false } = args;
+    const { project, query, category, limit = 10, enable_trace = false, activation } = args;
     debugLog(`[knowledge_search] Searching: project=${project || "all"}, query="${query || ""}", category=${category || "any"}, limit=${limit}`);
     // Phase 1: Capture total start time for latency measurement
     const totalStart = performance.now();
@@ -79,6 +79,7 @@ export async function knowledgeSearchHandler(args) {
         queryText: query || null,
         limit: Math.min(limit, 50),
         userId: PRISM_USER_ID,
+        activation,
     });
     const storageMs = performance.now() - storageStart;
     const totalMs = performance.now() - totalStart;
@@ -121,7 +122,7 @@ export async function knowledgeSearchHandler(args) {
         // Mutate results to surface effective importance
         for (const r of data.results) {
             if (typeof r.importance === 'number' && r.importance > 0) {
-                r.effective_importance = computeEffectiveImportance(r.importance, r.last_accessed_at, r.created_at);
+                r.effective_importance = computeEffectiveImportance(r.importance, r.last_accessed_at, r.created_at, Boolean(r.is_rollup));
             }
         }
     }
@@ -282,7 +283,7 @@ export async function sessionSearchMemoryHandler(args) {
     // When true, a MemoryTrace JSON block is appended as content[1].
     enable_trace = false, 
     // v5.2: Context-Weighted Retrieval — biases search toward active work context
-    context_boost = false, } = args;
+    context_boost = false, activation, } = args;
     debugLog(`[session_search_memory] Semantic search: query="${query}", ` +
         `project=${project || "all"}, limit=${limit}, threshold=${similarity_threshold}` +
         `${context_boost ? ", context_boost=ON" : ""}`);
@@ -374,6 +375,7 @@ export async function sessionSearchMemoryHandler(args) {
             limit: candidateLimit,
             similarityThreshold: similarity_threshold,
             userId: PRISM_USER_ID,
+            activation,
         });
         // Phase 1: Capture storage query latency and compute total
         const storageMs = performance.now() - storageStart;
@@ -444,7 +446,10 @@ export async function sessionSearchMemoryHandler(args) {
                     const timestamps = accessTimestamps.length > 0
                         ? accessTimestamps
                         : [new Date(r.created_at || now)];
-                    const Bi = baseLevelActivation(timestamps, now, PRISM_ACTR_DECAY);
+                    // Rollups represent consolidated semantic knowledge over many sessions.
+                    // 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);
@@ -473,6 +478,29 @@ export async function sessionSearchMemoryHandler(args) {
         // This MUST happen after re-ranking but BEFORE recording access events,
         // so we only log access for results actually delivered to the LLM.
         results.splice(limit);
+        if (results.length > 0) {
+            const topScore = PRISM_ACTR_ENABLED ? results[0]._actr_composite : results[0].similarity;
+            const secondScore = results.length > 1 ? (PRISM_ACTR_ENABLED ? results[1]._actr_composite : results[1].similarity) : 0;
+            const gapDistance = (topScore || 0) - (secondScore || 0);
+            const fallbackThreshold = PRISM_HDC_POLICY_FALLBACK_THRESHOLD || 0.85;
+            const clarifyThreshold = PRISM_HDC_POLICY_CLARIFY_THRESHOLD || 0.95;
+            const gapThreshold = clarifyThreshold - fallbackThreshold;
+            if ((topScore || 0) < fallbackThreshold || (results.length > 1 && gapDistance < gapThreshold)) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                results: [],
+                                meta: {
+                                    rejected: true,
+                                    reason: `Uncertainty Rejection: topScore (${(topScore || 0).toFixed(3)}) < ${fallbackThreshold} OR gapDistance (${gapDistance.toFixed(3)}) < ${gapThreshold.toFixed(3)}.`
+                                }
+                            }, null, 2)
+                        }],
+                    isError: false
+                };
+            }
+        }
         // Fire-and-forget: record access events for the final delivered results
         // v7.0: Writes to both access_log buffer AND legacy last_accessed_at
         const finalIds = results.map((r) => r.id).filter(Boolean);
@@ -487,7 +515,7 @@ export async function sessionSearchMemoryHandler(args) {
                 : "N/A";
             // Dynamic importance decay (uses ACT-R internally when enabled)
             const baseImportance = r.importance ?? 0;
-            const effectiveImportance = computeEffectiveImportance(baseImportance, r.last_accessed_at, r.created_at);
+            const effectiveImportance = computeEffectiveImportance(baseImportance, r.last_accessed_at, r.created_at, Boolean(r.is_rollup));
             const importanceStr = baseImportance > 0
                 ? `  Importance: ${effectiveImportance}${effectiveImportance !== baseImportance ? ` (base: ${baseImportance}, decayed)` : ""}\n`
                 : "";

package/dist/tools/ledgerHandlers.js

@@ -648,7 +648,7 @@ export async function sessionLoadContextHandler(args) {
         formattedContext += `\n⏳ Recent Sessions:\n` + d.recent_sessions.map((s) => {
             let impStr = "";
             if (typeof s.importance === 'number' && s.importance > 0) {
-                const eff = computeEffectiveImportance(s.importance, s.last_accessed_at, s.created_at);
+                const eff = computeEffectiveImportance(s.importance, s.last_accessed_at, s.created_at, Boolean(s.is_rollup));
                 impStr = ` [Imp: ${eff}]`;
             }
             return `  [${s.session_date?.split("T")[0]}]${impStr} ${s.summary}`;

package/dist/tools/sessionMemoryDefinitions.js

@@ -188,6 +188,16 @@ export const KNOWLEDGE_SEARCH_TOOL = {
                 description: "If true, returns a separate MEMORY TRACE content block with search strategy, " +
                     "latency breakdown, and scoring metadata for explainability. Default: false.",
             },
+            activation: {
+                type: "object",
+                description: "Configuration for ACT-R inspired Spreading Activation. Use this to find structurally related memories beyond direct semantic/keyword hits.",
+                properties: {
+                    enabled: { type: "boolean", description: "Enable spreading activation (default: false)." },
+                    iterations: { type: "integer", description: "Number of propagation loops (default: 3)." },
+                    spreadFactor: { type: "number", description: "Decay multiplier per step (default: 0.8)." },
+                    lateralInhibition: { type: "integer", description: "Maximum nodes returned (default: 7)." },
+                }
+            },
         },
         required: ["query"],
     },
@@ -344,6 +354,16 @@ export const SESSION_SEARCH_MEMORY_TOOL = {
                     "before embedding generation, naturally biasing results toward contextually relevant memories. " +
                     "Useful when searching within a specific project context. Default: false.",
             },
+            activation: {
+                type: "object",
+                description: "Configuration for ACT-R inspired Spreading Activation. Use this to find structurally related memories beyond direct semantic/keyword hits.",
+                properties: {
+                    enabled: { type: "boolean", description: "Enable spreading activation (default: false)." },
+                    iterations: { type: "integer", description: "Number of propagation loops (default: 3)." },
+                    spreadFactor: { type: "number", description: "Decay multiplier per step (default: 0.8)." },
+                    lateralInhibition: { type: "integer", description: "Maximum nodes returned (default: 7)." },
+                }
+            },
         },
         required: ["query"],
     },
@@ -440,6 +460,8 @@ export function isKnowledgeSearchArgs(args) {
         return false;
     if (a.enable_trace !== undefined && typeof a.enable_trace !== "boolean")
         return false;
+    if (a.activation !== undefined && typeof a.activation !== "object")
+        return false;
     return true;
 }
 export function isSessionSaveLedgerArgs(args) {
@@ -509,6 +531,8 @@ export function isSessionSearchMemoryArgs(args) {
         return false;
     if (a.context_boost !== undefined && typeof a.context_boost !== "boolean")
         return false;
+    if (a.activation !== undefined && typeof a.activation !== "object")
+        return false;
     return true;
 }
 // ─── v1.5.0: Type guard for backfill embeddings ──────────────

package/dist/utils/cognitiveMemory.js

@@ -46,7 +46,7 @@ import { PRISM_ACTR_ENABLED, PRISM_ACTR_DECAY, PRISM_ACTR_SIGMOID_MIDPOINT, PRIS
  * @param createdAtStr ISO string representing creation time (fallback).
  * @returns The effective importance score, rounded to 2 decimal places.
  */
-export function computeEffectiveImportance(baseImportance, lastAccessedStr, createdAtStr) {
+export function computeEffectiveImportance(baseImportance, lastAccessedStr, createdAtStr, isRollup = false) {
     if (baseImportance <= 0)
         return baseImportance;
     const now = new Date();
@@ -64,7 +64,8 @@ export function computeEffectiveImportance(baseImportance, lastAccessedStr, crea
     // Use a single-timestamp proxy: treat last_accessed_at as one access event.
     // This gives a simplified B_i = ln(t^(-d)) = -d × ln(t)
     // The full multi-timestamp B_i runs in graphHandlers.ts search pipeline.
-    const Bi = baseLevelActivation([referenceDate], now, PRISM_ACTR_DECAY);
+    const decayRate = isRollup ? PRISM_ACTR_DECAY * 0.5 : PRISM_ACTR_DECAY;
+    const Bi = baseLevelActivation([referenceDate], now, decayRate);
     // Normalize to (0, 1) via parameterized sigmoid
     const activationFactor = parameterizedSigmoid(Bi, PRISM_ACTR_SIGMOID_MIDPOINT, PRISM_ACTR_SIGMOID_STEEPNESS);
     // Scale importance by activation factor

package/dist/utils/llm/factory.js

@@ -148,3 +148,6 @@ export function getLLMProvider() {
 export function _resetLLMProvider() {
     providerInstance = null;
 }
+export function _setLLMProviderForTest(mock) {
+    providerInstance = mock;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "7.7.1",
+  "version": "7.8.0",
   "mcpName": "io.github.dcostenco/prism-mcp",
   "description": "The Mind Palace for AI Agents — adversarial evaluation (PLAN_CONTRACT→EVALUATE anti-sycophancy), fail-closed Dark Factory autonomous pipelines (3-gate parse→type→scope), persistent memory (SQLite/Supabase), ACT-R cognitive retrieval, behavioral learning & IDE rules sync, multi-agent Hivemind, time travel, visual dashboard. Zero-config local mode.",
   "module": "index.ts",