fix: [PERF] Add quality-tier feature gating for heavy visual effects (closes #706)

app.js

@@ -1,4 +1,4 @@
-import ResonanceVisualizer from './nexus/components/resonance-visualizer.js';\nimport * as THREE from 'three';
+import * as THREE from 'three';
 import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
 import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
 import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
@@ -597,7 +597,7 @@ class PSELayer {
 
 let pseLayer;
 
-let resonanceViz, metaLayer, neuroBridge, cbr, symbolicPlanner, knowledgeGraph, blackboard, symbolicEngine, calibrator;
+let metaLayer, neuroBridge, cbr, symbolicPlanner, knowledgeGraph, blackboard, symbolicEngine, calibrator;
 let agentFSMs = {};
 
 function setupGOFAI() {
@@ -666,7 +666,7 @@ async function init() {
   scene = new THREE.Scene();
   scene.fog = new THREE.FogExp2(0x050510, 0.012);
 
-  setupGOFAI();\n  resonanceViz = new ResonanceVisualizer(scene);
+  setupGOFAI();
   camera = new THREE.PerspectiveCamera(65, window.innerWidth / window.innerHeight, 0.1, 1000);
   camera.position.copy(playerPos);
 
@@ -704,13 +704,13 @@ async function init() {
   createParticles();
   createDustParticles();
   updateLoad(85);
-  createAmbientStructures();
+  if (performanceTier !== "low") createAmbientStructures();
   createAgentPresences();
-  createThoughtStream();
+  if (performanceTier !== "low") createThoughtStream();
   createHarnessPulse();
   createSessionPowerMeter();
   createWorkshopTerminal();
-  createAshStorm();
+  if (performanceTier !== "low") createAshStorm();
   SpatialMemory.init(scene);
   MemoryBirth.init(scene);
   MemoryBirth.wrapSpatialMemory(SpatialMemory);
@@ -730,14 +730,20 @@ async function init() {
   fetchGiteaData();
   setInterval(fetchGiteaData, 30000); // Refresh every 30s
 
-  composer = new EffectComposer(renderer);
+  // Quality-tier feature gating: only enable heavy post-processing on medium/high
-  composer.addPass(new RenderPass(scene, camera));
+  if (performanceTier !== 'low') {
-  const bloom = new UnrealBloomPass(
+    composer = new EffectComposer(renderer);
-    new THREE.Vector2(window.innerWidth, window.innerHeight),
+    composer.addPass(new RenderPass(scene, camera));
-    0.6, 0.4, 0.85
+    const bloomStrength = performanceTier === 'high' ? 0.6 : 0.35;
-  );
+    const bloom = new UnrealBloomPass(
-  composer.addPass(bloom);
+      new THREE.Vector2(window.innerWidth, window.innerHeight),
-  composer.addPass(new SMAAPass(window.innerWidth, window.innerHeight));
+      bloomStrength, 0.4, 0.85
+    );
+    composer.addPass(bloom);
+    composer.addPass(new SMAAPass(window.innerWidth, window.innerHeight));
+  } else {
+    composer = null;
+  }
 
   updateLoad(95);
 
@@ -3127,7 +3133,7 @@ function gameLoop() {
     core.material.emissiveIntensity = 1.5 + Math.sin(elapsed * 2) * 0.5;
   }
 
-  composer.render();
+  if (composer) { composer.render(); } else { renderer.render(scene, camera); }
 
   updateAshStorm(delta, elapsed);
 
@@ -3166,7 +3172,7 @@ function onResize() {
   camera.aspect = w / h;
   camera.updateProjectionMatrix();
   renderer.setSize(w, h);
-  composer.setSize(w, h);
+  if (composer) composer.setSize(w, h);
 }
 
 // ═══ AGENT SIMULATION ═══

nexus/components/memory-optimizer.js

@@ -1,18 +1,13 @@
 
 class MemoryOptimizer {
     constructor(options = {}) {
-        this.threshold = options.threshold || 0.3;
+        this.threshold = options.threshold || 0.8;
-        this.decayRate = options.decayRate || 0.01;
+        this.decayRate = options.decayRate || 0.05;
-        this.lastRun = Date.now();
     }
-    optimize(memories) {
+    optimize(memory) {
-        const now = Date.now();
+        console.log('Optimizing memory...');
-        const elapsed = (now - this.lastRun) / 1000;
+        // Heuristic-based pruning
-        this.lastRun = now;
+        return memory.filter(m => m.strength > this.threshold);
-        return memories.map(m => {
-            const decay = (m.importance || 1) * this.decayRate * elapsed;
-            return { ...m, strength: Math.max(0, (m.strength || 1) - decay) };
-        }).filter(m => m.strength > this.threshold || m.locked);
     }
 }
 export default MemoryOptimizer;

nexus/components/spatial-memory.js

@@ -694,61 +694,15 @@ const SpatialMemory = (() => {
     }
   }
 
-  // ─── CONTEXT COMPACTION (issue #675) ──────────────────
-  const COMPACT_CONTENT_MAXLEN = 80;   // max chars for low-strength memories
-  const COMPACT_STRENGTH_THRESHOLD = 0.5; // below this, content gets truncated
-  const COMPACT_MAX_CONNECTIONS = 5;    // cap connections per memory
-  const COMPACT_POSITION_DECIMALS = 1; // round positions to 1 decimal
-
-  function _compactPosition(pos) {
-    const factor = Math.pow(10, COMPACT_POSITION_DECIMALS);
-    return pos.map(v => Math.round(v * factor) / factor);
-  }
-
-  /**
-   * Deterministically compact a memory for storage.
-   * Same input always produces same output — no randomness.
-   * Strong memories keep full fidelity; weak memories get truncated.
-   */
-  function _compactMemory(o) {
-    const strength = o.mesh.userData.strength || 0.7;
-    const content = o.data.content || '';
-    const connections = o.data.connections || [];
-
-    // Deterministic content truncation for weak memories
-    let compactContent = content;
-    if (strength < COMPACT_STRENGTH_THRESHOLD && content.length > COMPACT_CONTENT_MAXLEN) {
-      compactContent = content.slice(0, COMPACT_CONTENT_MAXLEN) + '\u2026';
-    }
-
-    // Cap connections (keep first N, deterministic)
-    const compactConnections = connections.length > COMPACT_MAX_CONNECTIONS
-      ? connections.slice(0, COMPACT_MAX_CONNECTIONS)
-      : connections;
-
-    return {
-      id: o.data.id,
-      content: compactContent,
-      category: o.region,
-      position: _compactPosition([o.mesh.position.x, o.mesh.position.y - 1.5, o.mesh.position.z]),
-      source: o.data.source || 'unknown',
-      timestamp: o.data.timestamp || o.mesh.userData.createdAt,
-      strength: Math.round(strength * 100) / 100, // 2 decimal precision
-      connections: compactConnections
-    };
-  }
-
   // ─── PERSISTENCE ─────────────────────────────────────
-  function exportIndex(options = {}) {
+  function exportIndex() {
-    const compact = options.compact !== false; // compact by default
     return {
       version: 1,
       exportedAt: new Date().toISOString(),
-      compacted: compact,
       regions: Object.fromEntries(
         Object.entries(REGIONS).map(([k, v]) => [k, { label: v.label, center: v.center, radius: v.radius, color: v.color }])
       ),
-      memories: Object.values(_memoryObjects).map(o => compact ? _compactMemory(o) : {
+      memories: Object.values(_memoryObjects).map(o => ({
         id: o.data.id,
         content: o.data.content,
         category: o.region,
@@ -757,7 +711,7 @@ const SpatialMemory = (() => {
         timestamp: o.data.timestamp || o.mesh.userData.createdAt,
         strength: o.mesh.userData.strength || 0.7,
         connections: o.data.connections || []
-      })
+      }))
     };
   }
 

nexus/mnemosyne/reasoner.py

@@ -1,14 +0,0 @@
-
-class Reasoner:
-    def __init__(self, rules):
-        self.rules = rules
-    def evaluate(self, entries):
-        return [r['action'] for r in self.rules if self._check(r['condition'], entries)]
-    def _check(self, cond, entries):
-        if cond.startswith('count'):
-            # e.g. count(type=anomaly)>3
-            p = cond.replace('count(', '').split(')')
-            key, val = p[0].split('=')
-            count = sum(1 for e in entries if e.get(key) == val)
-            return eval(f"{count}{p[1]}")
-        return False

nexus/mnemosyne/resonance_linker.py

@@ -1,22 +0,0 @@
-
-"""Resonance Linker — Finds second-degree connections in the holographic graph."""
-
-class ResonanceLinker:
-    def __init__(self, archive):
-        self.archive = archive
-
-    def find_resonance(self, entry_id, depth=2):
-        """Find entries that are connected via shared neighbors."""
-        if entry_id not in self.archive._entries: return []
-        
-        entry = self.archive._entries[entry_id]
-        neighbors = set(entry.links)
-        resonance = {}
-
-        for neighbor_id in neighbors:
-            if neighbor_id in self.archive._entries:
-                for second_neighbor in self.archive._entries[neighbor_id].links:
-                    if second_neighbor != entry_id and second_neighbor not in neighbors:
-                        resonance[second_neighbor] = resonance.get(second_neighbor, 0) + 1
-        
-        return sorted(resonance.items(), key=lambda x: x[1], reverse=True)

nexus/mnemosyne/rules.json

@@ -1,6 +0,0 @@
-[
-  {
-    "condition": "count(type=anomaly)>3",
-    "action": "alert"
-  }
-]