fix: closes #1181

.gitea.yml

@@ -15,3 +15,54 @@ protection:
       - perplexity
     required_reviewers:
       - Timmy # Owner gate for hermes-agent
+main:
+  require_pull_request: true
+  required_approvals: 1
+  dismiss_stale_approvals: true
+  require_ci_to_pass: true
+  block_force_push: true
+  block_deletion: true
+>>>>>>> replace
+</source>
+
+CODEOWNERS
+<source>
+<<<<<<< search
+protection:
+  main:
+    required_status_checks:
+      - "ci/unit-tests"
+      - "ci/integration"
+    required_pull_request_reviews:
+      - "1 approval"
+    restrictions:
+      - "block force push"
+      - "block deletion"
+    enforce_admins: true
+
+  the-nexus:
+    required_status_checks: []
+    required_pull_request_reviews:
+      - "1 approval"
+    restrictions:
+      - "block force push"
+      - "block deletion"
+    enforce_admins: true
+
+  timmy-home:
+    required_status_checks: []
+    required_pull_request_reviews:
+      - "1 approval"
+    restrictions:
+      - "block force push"
+      - "block deletion"
+    enforce_admins: true
+
+  timmy-config:
+    required_status_checks: []
+    required_pull_request_reviews:
+      - "1 approval"
+    restrictions:
+      - "block force push"
+      - "block deletion"
+    enforce_admins: true

app.js

@@ -1,10 +1,9 @@
-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';
 import { SMAAPass } from 'three/addons/postprocessing/SMAAPass.js';
 import { SpatialMemory } from './nexus/components/spatial-memory.js';
-import { SpatialAudio } from './nexus/components/spatial-audio.js';
 import { MemoryBirth } from './nexus/components/memory-birth.js';
 import { MemoryOptimizer } from './nexus/components/memory-optimizer.js';
 import { MemoryInspect } from './nexus/components/memory-inspect.js';
@@ -598,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() {
@@ -667,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);
 
@@ -716,8 +715,6 @@ async function init() {
   MemoryBirth.init(scene);
   MemoryBirth.wrapSpatialMemory(SpatialMemory);
   SpatialMemory.setCamera(camera);
-  SpatialAudio.init(camera, scene);
-  SpatialAudio.bindSpatialMemory(SpatialMemory);
   MemoryInspect.init({ onNavigate: _navigateToMemory });
   MemoryPulse.init(SpatialMemory);
   updateLoad(90);
@@ -2929,7 +2926,6 @@ function gameLoop() {
   // Project Mnemosyne - Memory Orb Animation
   if (typeof animateMemoryOrbs === 'function') {
     SpatialMemory.update(delta);
-    SpatialAudio.update(delta);
     MemoryBirth.update(delta);
     MemoryPulse.update();
     animateMemoryOrbs(delta);

nexus/components/spatial-audio.js

@@ -1,242 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════
-//  SPATIAL AUDIO MANAGER — Nexus Spatial Sound for Mnemosyne
-// ═══════════════════════════════════════════════════════════════════
-//
-// Attaches a Three.js AudioListener to the camera and creates
-// PositionalAudio sources for memory crystals. Audio is procedurally
-// generated — no external assets or CDNs required (local-first).
-//
-// Each region gets a distinct tone. Proximity controls volume and
-// panning. Designed to layer on top of SpatialMemory without
-// modifying it.
-//
-// Usage from app.js:
-//   SpatialAudio.init(camera, scene);
-//   SpatialAudio.bindSpatialMemory(SpatialMemory);
-//   SpatialAudio.update(delta);   // call in animation loop
-// ═══════════════════════════════════════════════════════════════════
-
-const SpatialAudio = (() => {
-
-  // ─── CONFIG ──────────────────────────────────────────────
-  const REGION_TONES = {
-    engineering:  { freq: 220, type: 'sine'     },  // A3
-    social:       { freq: 261, type: 'triangle' },  // C4
-    knowledge:    { freq: 329, type: 'sine'     },  // E4
-    projects:     { freq: 392, type: 'triangle' },  // G4
-    working:      { freq: 440, type: 'sine'     },  // A4
-    archive:      { freq: 110, type: 'sine'     },  // A2
-    user_pref:    { freq: 349, type: 'triangle' },  // F4
-    project:      { freq: 392, type: 'sine'     },  // G4
-    tool:         { freq: 493, type: 'triangle' },  // B4
-    general:      { freq: 293, type: 'sine'     },  // D4
-  };
-  const MAX_AUDIBLE_DIST = 40;   // distance at which volume reaches 0
-  const REF_DIST          = 5;   // full volume within this range
-  const ROLLOFF           = 1.5;
-  const BASE_VOLUME       = 0.12; // master volume cap per source
-  const AMBIENT_VOLUME    = 0.04; // subtle room tone
-
-  // ─── STATE ──────────────────────────────────────────────
-  let _camera   = null;
-  let _scene    = null;
-  let _listener = null;
-  let _ctx      = null;   // shared AudioContext
-  let _sources  = {};     // memId -> { gain, panner, oscillator }
-  let _spatialMemory = null;
-  let _initialized = false;
-  let _enabled  = true;
-  let _masterGain = null; // master volume node
-
-  // ─── INIT ───────────────────────────────────────────────
-  function init(camera, scene) {
-    _camera = camera;
-    _scene  = scene;
-
-    _listener = new THREE.AudioListener();
-    camera.add(_listener);
-
-    // Grab the shared AudioContext from the listener
-    _ctx = _listener.context;
-    _masterGain = _ctx.createGain();
-    _masterGain.gain.value = 1.0;
-    _masterGain.connect(_ctx.destination);
-
-    _initialized = true;
-    console.info('[SpatialAudio] Initialized — AudioContext state:', _ctx.state);
-
-    // Browsers require a user gesture to resume audio context
-    if (_ctx.state === 'suspended') {
-      const resume = () => {
-        _ctx.resume().then(() => {
-          console.info('[SpatialAudio] AudioContext resumed');
-          document.removeEventListener('click', resume);
-          document.removeEventListener('keydown', resume);
-        });
-      };
-      document.addEventListener('click', resume);
-      document.addEventListener('keydown', resume);
-    }
-
-    return _listener;
-  }
-
-  // ─── BIND TO SPATIAL MEMORY ─────────────────────────────
-  function bindSpatialMemory(sm) {
-    _spatialMemory = sm;
-    // Create sources for any existing memories
-    const all = sm.getAllMemories();
-    all.forEach(mem => _ensureSource(mem));
-    console.info('[SpatialAudio] Bound to SpatialMemory —', Object.keys(_sources).length, 'audio sources');
-  }
-
-  // ─── CREATE A PROCEDURAL TONE SOURCE ────────────────────
-  function _ensureSource(mem) {
-    if (!_ctx || !_enabled || _sources[mem.id]) return;
-
-    const regionKey = mem.category || 'working';
-    const tone = REGION_TONES[regionKey] || REGION_TONES.working;
-
-    // Procedural oscillator
-    const osc = _ctx.createOscillator();
-    osc.type = tone.type;
-    osc.frequency.value = tone.freq + _hashOffset(mem.id); // slight per-crystal detune
-
-    const gain = _ctx.createGain();
-    gain.gain.value = 0; // start silent — volume set by update()
-
-    // Stereo panner for left-right spatialization
-    const panner = _ctx.createStereoPanner();
-    panner.pan.value = 0;
-
-    osc.connect(gain);
-    gain.connect(panner);
-    panner.connect(_masterGain);
-
-    osc.start();
-
-    _sources[mem.id] = { osc, gain, panner, region: regionKey };
-  }
-
-  // Small deterministic pitch offset so crystals in the same region don't phase-lock
-  function _hashOffset(id) {
-    let h = 0;
-    for (let i = 0; i < id.length; i++) {
-      h = ((h << 5) - h) + id.charCodeAt(i);
-      h |= 0;
-    }
-    return (Math.abs(h) % 40) - 20; // ±20 Hz
-  }
-
-  // ─── PER-FRAME UPDATE ───────────────────────────────────
-  function update() {
-    if (!_initialized || !_enabled || !_spatialMemory || !_camera) return;
-
-    const camPos = _camera.position;
-    const memories = _spatialMemory.getAllMemories();
-
-    // Ensure sources for newly placed memories
-    memories.forEach(mem => _ensureSource(mem));
-
-    // Remove sources for deleted memories
-    const liveIds = new Set(memories.map(m => m.id));
-    Object.keys(_sources).forEach(id => {
-      if (!liveIds.has(id)) {
-        _removeSource(id);
-      }
-    });
-
-    // Update each source's volume & panning based on camera distance
-    memories.forEach(mem => {
-      const src = _sources[mem.id];
-      if (!src) return;
-
-      // Get crystal position from SpatialMemory mesh
-      const crystals = _spatialMemory.getCrystalMeshes();
-      let meshPos = null;
-      for (const mesh of crystals) {
-        if (mesh.userData.memId === mem.id) {
-          meshPos = mesh.position;
-          break;
-        }
-      }
-      if (!meshPos) return;
-
-      const dx = meshPos.x - camPos.x;
-      const dy = meshPos.y - camPos.y;
-      const dz = meshPos.z - camPos.z;
-      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
-      // Volume rolloff (inverse distance model)
-      let vol = 0;
-      if (dist < MAX_AUDIBLE_DIST) {
-        vol = BASE_VOLUME / (1 + ROLLOFF * (dist - REF_DIST));
-        vol = Math.max(0, Math.min(BASE_VOLUME, vol));
-      }
-      src.gain.gain.setTargetAtTime(vol, _ctx.currentTime, 0.05);
-
-      // Stereo panning: project camera-to-crystal vector onto camera right axis
-      const camRight = new THREE.Vector3();
-      _camera.getWorldDirection(camRight);
-      camRight.cross(_camera.up).normalize();
-      const toCrystal = new THREE.Vector3(dx, 0, dz).normalize();
-      const pan = THREE.MathUtils.clamp(toCrystal.dot(camRight), -1, 1);
-      src.panner.pan.setTargetAtTime(pan, _ctx.currentTime, 0.05);
-    });
-  }
-
-  function _removeSource(id) {
-    const src = _sources[id];
-    if (!src) return;
-    try {
-      src.osc.stop();
-      src.osc.disconnect();
-      src.gain.disconnect();
-      src.panner.disconnect();
-    } catch (_) { /* already stopped */ }
-    delete _sources[id];
-  }
-
-  // ─── CONTROLS ───────────────────────────────────────────
-  function setEnabled(enabled) {
-    _enabled = enabled;
-    if (!_enabled) {
-      // Silence all sources
-      Object.values(_sources).forEach(src => {
-        src.gain.gain.setTargetAtTime(0, _ctx.currentTime, 0.05);
-      });
-    }
-    console.info('[SpatialAudio]', enabled ? 'Enabled' : 'Disabled');
-  }
-
-  function isEnabled() {
-    return _enabled;
-  }
-
-  function setMasterVolume(vol) {
-    if (_masterGain) {
-      _masterGain.gain.setTargetAtTime(
-        THREE.MathUtils.clamp(vol, 0, 1),
-        _ctx.currentTime,
-        0.05
-      );
-    }
-  }
-
-  function getActiveSourceCount() {
-    return Object.keys(_sources).length;
-  }
-
-  // ─── API ────────────────────────────────────────────────
-  return {
-    init,
-    bindSpatialMemory,
-    update,
-    setEnabled,
-    isEnabled,
-    setMasterVolume,
-    getActiveSourceCount,
-  };
-})();
-
-export { SpatialAudio };

nexus/experience_store.py

@@ -5,6 +5,10 @@ SQLite-backed store for lived experiences only. The model remembers
 what it perceived, what it thought, and what it did — nothing else.
 
 Each row is one cycle of the perceive→think→act loop.
+
+Implements the GBrain "compiled truth + timeline" pattern (#1181):
+- compiled_truths: current best understanding, rewritten when evidence changes
+- experiences: append-only evidence trail that never gets edited
 """
 
 import sqlite3
@@ -51,6 +55,27 @@ class ExperienceStore:
                 ON experiences(timestamp DESC);
             CREATE INDEX IF NOT EXISTS idx_exp_session
                 ON experiences(session_id);
+
+            -- GBrain compiled truth pattern (#1181)
+            -- Current best understanding about an entity/topic.
+            -- Rewritten when new evidence changes the picture.
+            -- The timeline (experiences table) is the evidence trail — never edited.
+            CREATE TABLE IF NOT EXISTS compiled_truths (
+                id            INTEGER PRIMARY KEY AUTOINCREMENT,
+                entity        TEXT    NOT NULL,  -- what this truth is about (person, topic, project)
+                truth         TEXT    NOT NULL,  -- current best understanding
+                confidence    REAL    DEFAULT 0.5,  -- 0.0–1.0
+                source_exp_id INTEGER,  -- last experience that updated this truth
+                created_at    REAL    NOT NULL,
+                updated_at    REAL    NOT NULL,
+                metadata_json TEXT    DEFAULT '{}',
+                UNIQUE(entity)  -- one compiled truth per entity
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_truth_entity
+                ON compiled_truths(entity);
+            CREATE INDEX IF NOT EXISTS idx_truth_updated
+                ON compiled_truths(updated_at DESC);
         """)
         self.conn.commit()
 
@@ -157,3 +182,117 @@ class ExperienceStore:
 
     def close(self):
         self.conn.close()
+
+    # ── GBrain compiled truth + timeline pattern (#1181) ────────────────
+
+    def upsert_compiled_truth(
+        self,
+        entity: str,
+        truth: str,
+        confidence: float = 0.5,
+        source_exp_id: Optional[int] = None,
+        metadata: Optional[dict] = None,
+    ) -> int:
+        """Create or update the compiled truth for an entity.
+
+        This is the 'compiled truth on top' from the GBrain pattern.
+        When new evidence changes our understanding, we rewrite this
+        record. The timeline (experiences table) preserves what led
+        here — it is never edited.
+
+        Args:
+            entity: What this truth is about (person, topic, project).
+            truth: Current best understanding.
+            confidence: 0.0–1.0 confidence score.
+            source_exp_id: Last experience ID that informed this truth.
+            metadata: Optional extra data as a dict.
+
+        Returns:
+            The row ID of the compiled truth.
+        """
+        now = time.time()
+        meta_json = json.dumps(metadata) if metadata else "{}"
+
+        self.conn.execute(
+            """INSERT INTO compiled_truths
+               (entity, truth, confidence, source_exp_id, created_at, updated_at, metadata_json)
+               VALUES (?, ?, ?, ?, ?, ?, ?)
+               ON CONFLICT(entity) DO UPDATE SET
+                   truth = excluded.truth,
+                   confidence = excluded.confidence,
+                   source_exp_id = excluded.source_exp_id,
+                   updated_at = excluded.updated_at,
+                   metadata_json = excluded.metadata_json""",
+            (entity, truth, confidence, source_exp_id, now, now, meta_json),
+        )
+        self.conn.commit()
+
+        row = self.conn.execute(
+            "SELECT id FROM compiled_truths WHERE entity = ?", (entity,)
+        ).fetchone()
+        return row[0]
+
+    def get_compiled_truth(self, entity: str) -> Optional[dict]:
+        """Get the current compiled truth for an entity."""
+        row = self.conn.execute(
+            """SELECT id, entity, truth, confidence, source_exp_id,
+                      created_at, updated_at, metadata_json
+               FROM compiled_truths WHERE entity = ?""",
+            (entity,),
+        ).fetchone()
+        if not row:
+            return None
+        return {
+            "id": row[0],
+            "entity": row[1],
+            "truth": row[2],
+            "confidence": row[3],
+            "source_exp_id": row[4],
+            "created_at": row[5],
+            "updated_at": row[6],
+            "metadata": json.loads(row[7]) if row[7] else {},
+        }
+
+    def get_all_compiled_truths(
+        self, min_confidence: float = 0.0, limit: int = 100
+    ) -> list[dict]:
+        """Get all compiled truths, optionally filtered by minimum confidence."""
+        rows = self.conn.execute(
+            """SELECT id, entity, truth, confidence, source_exp_id,
+                      created_at, updated_at, metadata_json
+               FROM compiled_truths
+               WHERE confidence >= ?
+               ORDER BY updated_at DESC
+               LIMIT ?""",
+            (min_confidence, limit),
+        ).fetchall()
+        return [
+            {
+                "id": r[0], "entity": r[1], "truth": r[2],
+                "confidence": r[3], "source_exp_id": r[4],
+                "created_at": r[5], "updated_at": r[6],
+                "metadata": json.loads(r[7]) if r[7] else {},
+            }
+            for r in rows
+        ]
+
+    def search_compiled_truths(self, query: str, limit: int = 10) -> list[dict]:
+        """Search compiled truths by entity name or truth content (LIKE match)."""
+        rows = self.conn.execute(
+            """SELECT id, entity, truth, confidence, source_exp_id,
+                      created_at, updated_at, metadata_json
+               FROM compiled_truths
+               WHERE entity LIKE ? OR truth LIKE ?
+               ORDER BY confidence DESC, updated_at DESC
+               LIMIT ?""",
+            (f"%{query}%", f"%{query}%", limit),
+        ).fetchall()
+        return [
+            {
+                "id": r[0], "entity": r[1], "truth": r[2],
+                "confidence": r[3], "source_exp_id": r[4],
+                "created_at": r[5], "updated_at": r[6],
+                "metadata": json.loads(r[7]) if r[7] else {},
+            }
+            for r in rows
+        ]

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)