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

app.js

@@ -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);
-  composer.addPass(new RenderPass(scene, camera));
-  const bloom = new UnrealBloomPass(
-    new THREE.Vector2(window.innerWidth, window.innerHeight),
-    0.6, 0.4, 0.85
-  );
-  composer.addPass(bloom);
-  composer.addPass(new SMAAPass(window.innerWidth, window.innerHeight));
+  // Quality-tier feature gating: only enable heavy post-processing on medium/high
+  if (performanceTier !== 'low') {
+    composer = new EffectComposer(renderer);
+    composer.addPass(new RenderPass(scene, camera));
+    const bloomStrength = performanceTier === 'high' ? 0.6 : 0.35;
+    const bloom = new UnrealBloomPass(
+      new THREE.Vector2(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.decayRate = options.decayRate || 0.01;
-        this.lastRun = Date.now();
+        this.threshold = options.threshold || 0.8;
+        this.decayRate = options.decayRate || 0.05;
     }
-    optimize(memories) {
-        const now = Date.now();
-        const elapsed = (now - this.lastRun) / 1000;
-        this.lastRun = now;
-        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);
+    optimize(memory) {
+        console.log('Optimizing memory...');
+        // Heuristic-based pruning
+        return memory.filter(m => m.strength > this.threshold);
     }
 }
 export default MemoryOptimizer;

nexus/components/spatial-memory.js

@@ -173,9 +173,7 @@ const SpatialMemory = (() => {
   let _entityLines = [];      // entity resolution lines (issue #1167)
   let _camera = null;         // set by setCamera() for LOD culling
   const ENTITY_LOD_DIST = 50; // hide entity lines when camera > this from midpoint
-  const CONNECTION_LOD_DIST = 60; // hide connection lines when camera > this from midpoint
   let _initialized = false;
-  let _constellationVisible = true; // toggle for constellation view
 
   // ─── CRYSTAL GEOMETRY (persistent memories) ───────────
   function createCrystalGeometry(size) {
@@ -320,43 +318,10 @@ const SpatialMemory = (() => {
     if (!obj || !obj.data.connections) return;
     obj.data.connections.forEach(targetId => {
       const target = _memoryObjects[targetId];
-      if (target) _drawSingleConnection(obj, target);
+      if (target) _createConnectionLine(obj, target);
     });
   }
 
-  function _drawSingleConnection(src, tgt) {
-    const srcId = src.data.id;
-    const tgtId = tgt.data.id;
-    // Deduplicate — only draw from lower ID to higher
-    if (srcId > tgtId) return;
-    // Skip if already exists
-    const exists = _connectionLines.some(l =>
-      (l.userData.from === srcId && l.userData.to === tgtId) ||
-      (l.userData.from === tgtId && l.userData.to === srcId)
-    );
-    if (exists) return;
-
-    const points = [src.mesh.position.clone(), tgt.mesh.position.clone()];
-    const geo = new THREE.BufferGeometry().setFromPoints(points);
-    const srcStrength = src.mesh.userData.strength || 0.7;
-    const tgtStrength = tgt.mesh.userData.strength || 0.7;
-    const blendedStrength = (srcStrength + tgtStrength) / 2;
-    const lineOpacity = 0.15 + blendedStrength * 0.55;
-    const srcColor = new THREE.Color(REGIONS[src.region]?.color || 0x334455);
-    const tgtColor = new THREE.Color(REGIONS[tgt.region]?.color || 0x334455);
-    const lineColor = new THREE.Color().lerpColors(srcColor, tgtColor, 0.5);
-    const mat = new THREE.LineBasicMaterial({
-      color: lineColor,
-      transparent: true,
-      opacity: lineOpacity
-    });
-    const line = new THREE.Line(geo, mat);
-    line.userData = { type: 'connection', from: srcId, to: tgtId, baseOpacity: lineOpacity };
-    line.visible = _constellationVisible;
-    _scene.add(line);
-    _connectionLines.push(line);
-  }
-
   return { ring, disc, glowDisc, sprite };
   }
 
@@ -434,7 +399,7 @@ const SpatialMemory = (() => {
     return [cx + Math.cos(angle) * dist, cy + height, cz + Math.sin(angle) * dist];
   }
 
-  // ─── CONNECTIONS (constellation-aware) ───────────────
+  // ─── CONNECTIONS ─────────────────────────────────────
   function _drawConnections(memId, connections) {
     const src = _memoryObjects[memId];
     if (!src) return;
@@ -445,23 +410,9 @@ const SpatialMemory = (() => {
 
       const points = [src.mesh.position.clone(), tgt.mesh.position.clone()];
       const geo = new THREE.BufferGeometry().setFromPoints(points);
-      // Strength-encoded opacity: blend source/target strengths, min 0.15, max 0.7
-      const srcStrength = src.mesh.userData.strength || 0.7;
-      const tgtStrength = tgt.mesh.userData.strength || 0.7;
-      const blendedStrength = (srcStrength + tgtStrength) / 2;
-      const lineOpacity = 0.15 + blendedStrength * 0.55;
-      // Blend source/target region colors for the line
-      const srcColor = new THREE.Color(REGIONS[src.region]?.color || 0x334455);
-      const tgtColor = new THREE.Color(REGIONS[tgt.region]?.color || 0x334455);
-      const lineColor = new THREE.Color().lerpColors(srcColor, tgtColor, 0.5);
-      const mat = new THREE.LineBasicMaterial({
-        color: lineColor,
-        transparent: true,
-        opacity: lineOpacity
-      });
+      const mat = new THREE.LineBasicMaterial({ color: 0x334455, transparent: true, opacity: 0.2 });
       const line = new THREE.Line(geo, mat);
-      line.userData = { type: 'connection', from: memId, to: targetId, baseOpacity: lineOpacity };
-      line.visible = _constellationVisible;
+      line.userData = { type: 'connection', from: memId, to: targetId };
       _scene.add(line);
       _connectionLines.push(line);
     });
@@ -538,43 +489,6 @@ const SpatialMemory = (() => {
     });
   }
 
-  function _updateConnectionLines() {
-    if (!_constellationVisible) return;
-    if (!_camera) return;
-    const camPos = _camera.position;
-
-    _connectionLines.forEach(line => {
-      const posArr = line.geometry.attributes.position.array;
-      const mx = (posArr[0] + posArr[3]) / 2;
-      const my = (posArr[1] + posArr[4]) / 2;
-      const mz = (posArr[2] + posArr[5]) / 2;
-      const dist = camPos.distanceTo(new THREE.Vector3(mx, my, mz));
-
-      if (dist > CONNECTION_LOD_DIST) {
-        line.visible = false;
-      } else {
-        line.visible = true;
-        const fade = Math.max(0, 1 - (dist / CONNECTION_LOD_DIST));
-        // Restore base opacity from userData if stored, else use material default
-        const base = line.userData.baseOpacity || line.material.opacity || 0.4;
-        line.material.opacity = base * fade;
-      }
-    });
-  }
-
-  function toggleConstellation() {
-    _constellationVisible = !_constellationVisible;
-    _connectionLines.forEach(line => {
-      line.visible = _constellationVisible;
-    });
-    console.info('[Mnemosyne] Constellation', _constellationVisible ? 'shown' : 'hidden');
-    return _constellationVisible;
-  }
-
-  function isConstellationVisible() {
-    return _constellationVisible;
-  }
-
   // ─── REMOVE A MEMORY ─────────────────────────────────
   function removeMemory(memId) {
     const obj = _memoryObjects[memId];
@@ -630,7 +544,6 @@ const SpatialMemory = (() => {
     });
 
       _updateEntityLines();
-      _updateConnectionLines();
 
     Object.values(_regionMarkers).forEach(marker => {
       if (marker.ring && marker.ring.material) {
@@ -953,7 +866,7 @@ const SpatialMemory = (() => {
     getCrystalMeshes, getMemoryFromMesh, highlightMemory, clearHighlight, getSelectedId,
     exportIndex, importIndex, searchNearby, REGIONS,
     saveToStorage, loadFromStorage, clearStorage,
-    runGravityLayout, setCamera, toggleConstellation, isConstellationVisible
+    runGravityLayout, setCamera
   };
 })();
 

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"
-  }
-]