fix: [PANELS] Add heartbeat / morning briefing panel tied to Hermes state (closes #698)

.gitignore

@@ -7,3 +7,6 @@ mempalace/__pycache__/
 
 # Prevent agents from writing to wrong path (see issue #1145)
 public/nexus/
+
+__pycache__/
+*.pyc

app.js

@@ -4,6 +4,7 @@ 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 { SessionRooms } from './nexus/components/session-rooms.js';
 
 // ═══════════════════════════════════════════
 // NEXUS v1.1 — Portal System Update
@@ -705,12 +706,15 @@ async function init() {
   createWorkshopTerminal();
   createAshStorm();
   SpatialMemory.init(scene);
+  SessionRooms.init(scene, camera, null);
   updateLoad(90);
 
   loadSession();
   connectHermes();
   fetchGiteaData();
   setInterval(fetchGiteaData, 30000); // Refresh every 30s
+  updateHeartbeatBriefing(); // Initial briefing load
+  setInterval(updateHeartbeatBriefing, 60000); // Refresh briefing every 60s
 
   composer = new EffectComposer(renderer);
   composer.addPass(new RenderPass(scene, camera));
@@ -1138,6 +1142,7 @@ async function fetchGiteaData() {
       const worldState = JSON.parse(atob(content.content));
       updateNexusCommand(worldState);
       updateSovereignHealth();
+      updateHeartbeatBriefing();
     }
   } catch (e) {
     console.error('Failed to fetch Gitea data:', e);
@@ -1233,6 +1238,127 @@ function updateNexusCommand(state) {
   terminal.updatePanelText(lines);
 }
 
+// ═══ HEARTBEAT BRIEFING PANEL ═════════════════════════════════════════
+async function updateHeartbeatBriefing() {
+  const container = document.getElementById('heartbeat-briefing-content');
+  const pulseDot = document.querySelector('.hb-pulse-dot');
+  if (!container) return;
+
+  let data = null;
+  try {
+    // Derive briefing endpoint from current location or fallback to localhost
+    const briefingUrl = window.location.protocol === 'file:'
+      ? 'http://localhost:8766/api/briefing'
+      : `${window.location.protocol}//${window.location.hostname}:8766/api/briefing`;
+    const res = await fetch(briefingUrl);
+    if (res.ok) data = await res.json();
+  } catch (e) {
+    // Server not reachable — show honest offline state
+  }
+
+  if (!data) {
+    if (pulseDot) pulseDot.classList.add('offline');
+    container.innerHTML = '<div class="hb-empty">Briefing offline<br>No connection to Nexus gateway</div>';
+    return;
+  }
+
+  if (pulseDot) pulseDot.classList.remove('offline');
+
+  let html = '';
+
+  // ── Core Heartbeat ──
+  html += '<div class="briefing-section">';
+  html += '<div class="briefing-section-label">Nexus Core</div>';
+  const hb = data.core_heartbeat;
+  if (hb) {
+    const age = hb.age_secs != null ? hb.age_secs : '?';
+    const ageLabel = typeof age === 'number'
+      ? (age < 60 ? `${age.toFixed(0)}s ago` : `${(age / 60).toFixed(1)}m ago`)
+      : age;
+    const isAlive = typeof age === 'number' && age < 120;
+    html += `<div class="hb-core-row">
+      <span class="hb-core-status ${isAlive ? 'alive' : 'dead'}">${isAlive ? '● ALIVE' : '○ STALE'}</span>
+      <span class="hb-core-meta">cycle ${hb.cycle || '?'} · ${hb.model || 'unknown'} · ${ageLabel}</span>
+    </div>`;
+    html += `<div class="hb-core-meta">status: ${hb.status || '?'}</div>`;
+  } else {
+    html += '<div class="hb-core-row"><span class="hb-core-status dead">○ NO DATA</span></div>';
+  }
+  html += '</div>';
+
+  // ── Cron Heartbeats ──
+  const cron = data.cron_heartbeat;
+  if (cron && cron.jobs && cron.jobs.length > 0) {
+    html += '<div class="briefing-section">';
+    html += '<div class="briefing-section-label">Cron Heartbeats</div>';
+    html += `<div class="hb-cron-row">
+      <span class="hb-cron-healthy">● ${cron.healthy_count} healthy</span>
+      ${cron.stale_count > 0 ? `<span class="hb-cron-stale">⚠ ${cron.stale_count} stale</span>` : ''}
+    </div>`;
+    for (const job of cron.jobs.slice(0, 5)) {
+      const cls = job.healthy ? 'healthy' : 'stale';
+      html += `<div class="hb-cron-job">
+        <span class="hb-cron-job-name">${esc(job.job)}</span>
+        <span class="hb-cron-job-status ${cls}">${esc(job.message)}</span>
+      </div>`;
+    }
+    if (cron.jobs.length > 5) {
+      html += `<div class="hb-core-meta">+${cron.jobs.length - 5} more jobs</div>`;
+    }
+    html += '</div>';
+  }
+
+  // ── Morning Report ──
+  const report = data.morning_report;
+  if (report) {
+    html += '<div class="briefing-section">';
+    html += '<div class="briefing-section-label">Latest Report</div>';
+
+    // Aggregate stats
+    let totalClosed = 0, totalMerged = 0;
+    if (report.repos) {
+      for (const r of Object.values(report.repos)) {
+        totalClosed += r.closed_issues || 0;
+        totalMerged += r.merged_prs || 0;
+      }
+    }
+    html += `<div class="hb-stats-row">
+      <div class="hb-stat"><span class="hb-stat-value" style="color:#4af0c0">${totalClosed}</span><span class="hb-stat-label">Closed</span></div>
+      <div class="hb-stat"><span class="hb-stat-value" style="color:#7b5cff">${totalMerged}</span><span class="hb-stat-label">Merged</span></div>
+      <div class="hb-stat"><span class="hb-stat-value" style="color:#ffd700">${(report.blockers || []).length}</span><span class="hb-stat-label">Blockers</span></div>
+    </div>`;
+
+    // Highlights (up to 3)
+    if (report.highlights && report.highlights.length > 0) {
+      for (const h of report.highlights.slice(0, 3)) {
+        html += `<div class="hb-core-meta">+ ${esc(h)}</div>`;
+      }
+    }
+
+    // Blockers
+    if (report.blockers && report.blockers.length > 0) {
+      for (const b of report.blockers) {
+        html += `<div class="hb-blocker">⚠ ${esc(b)}</div>`;
+      }
+    }
+
+    html += `<div class="hb-timestamp">Report: ${esc(report.generated_at || '?')}</div>`;
+    html += '</div>';
+  }
+
+  // ── Timestamp ──
+  html += `<div class="hb-timestamp">Briefing updated: ${new Date().toLocaleTimeString('en-US', { hour12: false })}</div>`;
+
+  container.innerHTML = html;
+}
+
+function esc(str) {
+  if (!str) return '';
+  const d = document.createElement('div');
+  d.textContent = String(str);
+  return d.innerHTML;
+}
+
 // ═══ AGENT PRESENCE SYSTEM ═══
 function createAgentPresences() {
   const agentData = [
@@ -1915,8 +2041,19 @@ function setupControls() {
           }
         }
 
+        // Priority 3: Session rooms (Mnemosyne #1171)
+        const roomMeshes = SessionRooms.getClickableMeshes();
+        if (roomMeshes.length > 0) {
+          const roomHits = raycaster.intersectObjects(roomMeshes, false);
+          if (roomHits.length > 0) {
+            const session = SessionRooms.handleRoomClick(roomHits[0].object);
+            if (session) { _showSessionRoomPanel(session); return; }
+          }
+        }
+
         // Clicked empty space — dismiss panel
         dismissMemoryPanel();
+        _dismissSessionRoomPanel();
       }
     }
   });
@@ -2734,6 +2871,62 @@ function _dismissMemoryPanelForce() {
   }, 200);
 }
 
+/**
+ * Show the session room HUD panel when a chamber is entered.
+ * @param {object} session — { id, timestamp, facts[] }
+ */
+function _showSessionRoomPanel(session) {
+  const panel = document.getElementById('session-room-panel');
+  if (!panel) return;
+
+  const dt = session.timestamp ? new Date(session.timestamp) : new Date();
+  const tsEl = document.getElementById('session-room-timestamp');
+  if (tsEl) tsEl.textContent = isNaN(dt.getTime()) ? session.id : dt.toLocaleString();
+
+  const countEl = document.getElementById('session-room-fact-count');
+  const facts = session.facts || [];
+  if (countEl) countEl.textContent = facts.length + (facts.length === 1 ? ' fact' : ' facts') + ' in this chamber';
+
+  const listEl = document.getElementById('session-room-facts');
+  if (listEl) {
+    listEl.innerHTML = '';
+    facts.slice(0, 8).forEach(f => {
+      const item = document.createElement('div');
+      item.className = 'session-room-fact-item';
+      item.textContent = f.content || f.id || '(unknown)';
+      item.title = f.content || '';
+      listEl.appendChild(item);
+    });
+    if (facts.length > 8) {
+      const more = document.createElement('div');
+      more.className = 'session-room-fact-item';
+      more.style.color = 'rgba(200,180,255,0.4)';
+      more.textContent = '\u2026 ' + (facts.length - 8) + ' more';
+      listEl.appendChild(more);
+    }
+  }
+
+  // Close button
+  const closeBtn = document.getElementById('session-room-close');
+  if (closeBtn) closeBtn.onclick = () => _dismissSessionRoomPanel();
+
+  panel.classList.remove('session-panel-fade-out');
+  panel.style.display = 'block';
+}
+
+/**
+ * Dismiss the session room panel.
+ */
+function _dismissSessionRoomPanel() {
+  const panel = document.getElementById('session-room-panel');
+  if (!panel || panel.style.display === 'none') return;
+  panel.classList.add('session-panel-fade-out');
+  setTimeout(() => {
+    panel.style.display = 'none';
+    panel.classList.remove('session-panel-fade-out');
+  }, 200);
+}
+
 
 function gameLoop() {
   requestAnimationFrame(gameLoop);
@@ -2765,6 +2958,9 @@ function gameLoop() {
     animateMemoryOrbs(delta);
   }
 
+  // Project Mnemosyne - Session Rooms (#1171)
+  SessionRooms.update(delta);
+
 
   const mode = NAV_MODES[navModeIdx];
   const chatActive = document.activeElement === document.getElementById('chat-input');
@@ -3288,12 +3484,52 @@ init().then(() => {
     { id: 'mem_hermes_chat', content: 'First conversation through the Hermes gateway', category: 'social', strength: 0.7, connections: [] },
     { id: 'mem_mnemosyne_start', content: 'Project Mnemosyne began — the living archive awakens', category: 'projects', strength: 0.9, connections: ['mem_nexus_birth', 'mem_spatial_schema'] },
     { id: 'mem_spatial_schema', content: 'Spatial Memory Schema defined — memories gain permanent homes', category: 'engineering', strength: 0.8, connections: ['mem_mnemosyne_start'] },
+    // MemPalace category zone demos — issue #1168
+    { id: 'mem_pref_dark_mode', content: 'User prefers dark mode and monospace fonts', category: 'user_pref', strength: 0.9, connections: [] },
+    { id: 'mem_pref_verbose_logs', content: 'User prefers verbose logging during debug sessions', category: 'user_pref', strength: 0.7, connections: [] },
+    { id: 'mem_proj_nexus_goal', content: 'The Nexus goal: local-first 3D training ground for Timmy', category: 'project', strength: 0.95, connections: ['mem_proj_mnemosyne'] },
+    { id: 'mem_proj_mnemosyne', content: 'Project Mnemosyne: holographic living archive of facts', category: 'project', strength: 0.85, connections: ['mem_proj_nexus_goal'] },
+    { id: 'mem_tool_three_js', content: 'Three.js — 3D rendering library used for the Nexus world', category: 'tool', strength: 0.8, connections: [] },
+    { id: 'mem_tool_gitea', content: 'Gitea API at forge.alexanderwhitestone.com for issue tracking', category: 'tool', strength: 0.75, connections: [] },
+    { id: 'mem_gen_websocket', content: 'WebSocket bridge (server.py) connects Timmy cognition to the browser', category: 'general', strength: 0.7, connections: [] },
+    { id: 'mem_gen_hermes', content: 'Hermes harness: telemetry and durable truth pipeline', category: 'general', strength: 0.65, connections: [] },
   ];
   demoMemories.forEach(m => SpatialMemory.placeMemory(m));
 
   // Gravity well clustering — attract related crystals, bake positions (issue #1175)
   SpatialMemory.runGravityLayout();
 
+  // Project Mnemosyne — seed demo session rooms (#1171)
+  // Sessions group facts by conversation/work session with a timestamp.
+  const demoSessions = [
+    {
+      id: 'session_2026_03_01',
+      timestamp: '2026-03-01T10:00:00.000Z',
+      facts: [
+        { id: 'mem_nexus_birth',     content: 'The Nexus came online — first render of the 3D world',    category: 'knowledge',    strength: 0.95 },
+        { id: 'mem_mnemosyne_start', content: 'Project Mnemosyne began — the living archive awakens',    category: 'projects',     strength: 0.9 },
+      ]
+    },
+    {
+      id: 'session_2026_03_15',
+      timestamp: '2026-03-15T14:30:00.000Z',
+      facts: [
+        { id: 'mem_first_portal',    content: 'First portal deployed — connection to external service',  category: 'engineering',  strength: 0.85 },
+        { id: 'mem_hermes_chat',     content: 'First conversation through the Hermes gateway',           category: 'social',       strength: 0.7 },
+        { id: 'mem_spatial_schema',  content: 'Spatial Memory Schema defined — memories gain homes',     category: 'engineering',  strength: 0.8 },
+      ]
+    },
+    {
+      id: 'session_2026_04_10',
+      timestamp: '2026-04-10T09:00:00.000Z',
+      facts: [
+        { id: 'mem_session_rooms',   content: 'Session rooms introduced — holographic chambers per session', category: 'projects', strength: 0.88 },
+        { id: 'mem_gravity_wells',   content: 'Gravity-well clustering bakes crystal positions on load',  category: 'engineering',  strength: 0.75 },
+      ]
+    }
+  ];
+  SessionRooms.updateSessions(demoSessions);
+
   fetchGiteaData();
   setInterval(fetchGiteaData, 30000);
   runWeeklyAudit();

index.html

@@ -96,6 +96,12 @@
       <div class="panel-header">SOVEREIGN HEALTH</div>
       <div id="sovereign-health-content" class="panel-content"></div>
     </div>
+    <div class="hud-panel hud-panel-briefing" id="heartbeat-briefing-log">
+      <div class="panel-header">
+        <span class="hb-pulse-dot"></span> HEARTBEAT BRIEFING
+      </div>
+      <div id="heartbeat-briefing-content" class="panel-content"></div>
+    </div>
     <div class="hud-panel" id="calibrator-log">
       <div class="panel-header">ADAPTIVE CALIBRATOR</div>
       <div id="calibrator-log-content" class="panel-content"></div>
@@ -236,6 +242,21 @@
     </div>
   </div>
 
+  <!-- Session Room HUD Panel (Mnemosyne #1171) -->
+  <div id="session-room-panel" class="session-room-panel" style="display:none;">
+    <div class="session-room-panel-content">
+      <div class="session-room-header">
+        <span class="session-room-icon">&#x25A1;</span>
+        <div class="session-room-title">SESSION CHAMBER</div>
+        <button class="session-room-close" id="session-room-close" title="Close">&#x2715;</button>
+      </div>
+      <div class="session-room-timestamp" id="session-room-timestamp">&mdash;</div>
+      <div class="session-room-fact-count" id="session-room-fact-count">0 facts</div>
+      <div class="session-room-facts" id="session-room-facts"></div>
+      <div class="session-room-hint">Flying into chamber&hellip;</div>
+    </div>
+  </div>
+
   <!-- Portal Atlas Overlay -->
   <div id="atlas-overlay" class="atlas-overlay" style="display:none;">
     <div class="atlas-content">

nexus/components/session-rooms.js

@@ -0,0 +1,413 @@
+// ═══════════════════════════════════════════════════════
+//  PROJECT MNEMOSYNE — SESSION ROOMS (Issue #1171)
+// ═══════════════════════════════════════════════════════
+//
+// Groups memories by session into holographic chambers.
+// Each session becomes a wireframe cube floating in space.
+// Rooms are arranged chronologically along a spiral.
+// Click a room to fly inside; distant rooms LOD to a point.
+//
+// Usage from app.js:
+//   SessionRooms.init(scene, camera, controls);
+//   SessionRooms.updateSessions(sessions);   // [{id, timestamp, facts[]}]
+//   SessionRooms.update(delta);              // call each frame
+//   SessionRooms.getClickableMeshes();       // for raycasting
+//   SessionRooms.handleRoomClick(mesh);      // trigger fly-in
+// ═══════════════════════════════════════════════════════
+
+const SessionRooms = (() => {
+
+  // ─── CONSTANTS ───────────────────────────────────────
+  const MAX_ROOMS        = 20;
+  const ROOM_SIZE        = 9;          // wireframe cube edge length
+  const ROOM_HALF        = ROOM_SIZE / 2;
+  const LOD_THRESHOLD    = 55;         // distance: full → point
+  const LOD_HYSTERESIS   = 5;          // buffer to avoid flicker
+  const SPIRAL_BASE_R    = 20;         // spiral inner radius
+  const SPIRAL_R_STEP    = 5;          // radius growth per room
+  const SPIRAL_ANGLE_INC = 2.399;      // golden angle (radians)
+  const SPIRAL_Y_STEP    = 1.5;        // vertical rise per room
+  const FLY_DURATION     = 1.5;        // seconds for fly-in tween
+  const FLY_TARGET_DEPTH = ROOM_HALF - 1.5; // how deep inside to stop
+
+  const ROOM_COLOR       = 0x7b5cff;   // violet — mnemosyne accent
+  const POINT_COLOR      = 0x9b7cff;
+  const LABEL_COLOR      = '#c8b4ff';
+  const STORAGE_KEY      = 'mnemosyne_sessions_v1';
+
+  // ─── STATE ────────────────────────────────────────────
+  let _scene    = null;
+  let _camera   = null;
+  let _controls = null;
+
+  let _rooms        = [];   // array of room objects
+  let _sessionIndex = {};   // id → room object
+
+  // Fly-in tween state
+  let _flyActive   = false;
+  let _flyElapsed  = 0;
+  let _flyFrom     = null;
+  let _flyTo       = null;
+  let _flyLookFrom = null;
+  let _flyLookTo   = null;
+  let _flyActiveRoom = null;
+
+  // ─── SPIRAL POSITION ──────────────────────────────────
+  function _spiralPos(index) {
+    const angle = index * SPIRAL_ANGLE_INC;
+    const r     = SPIRAL_BASE_R + index * SPIRAL_R_STEP;
+    const y     = index * SPIRAL_Y_STEP;
+    return new THREE.Vector3(
+      Math.cos(angle) * r,
+      y,
+      Math.sin(angle) * r
+    );
+  }
+
+  // ─── CREATE ROOM ──────────────────────────────────────
+  function _createRoom(session, index) {
+    const pos = _spiralPos(index);
+    const group = new THREE.Group();
+    group.position.copy(pos);
+
+    // Wireframe cube
+    const boxGeo   = new THREE.BoxGeometry(ROOM_SIZE, ROOM_SIZE, ROOM_SIZE);
+    const edgesGeo = new THREE.EdgesGeometry(boxGeo);
+    const edgesMat = new THREE.LineBasicMaterial({
+      color: ROOM_COLOR,
+      transparent: true,
+      opacity: 0.55
+    });
+    const wireframe = new THREE.LineSegments(edgesGeo, edgesMat);
+    wireframe.userData = { type: 'session_room_wireframe', sessionId: session.id };
+    group.add(wireframe);
+
+    // Collision mesh (invisible, for raycasting)
+    const hitGeo = new THREE.BoxGeometry(ROOM_SIZE, ROOM_SIZE, ROOM_SIZE);
+    const hitMat = new THREE.MeshBasicMaterial({
+      visible: false,
+      transparent: true,
+      opacity: 0,
+      side: THREE.FrontSide
+    });
+    const hitMesh = new THREE.Mesh(hitGeo, hitMat);
+    hitMesh.userData = { type: 'session_room', sessionId: session.id, roomIndex: index };
+    group.add(hitMesh);
+
+    // LOD point (small sphere shown at distance)
+    const pointGeo = new THREE.SphereGeometry(0.5, 6, 4);
+    const pointMat = new THREE.MeshBasicMaterial({
+      color: POINT_COLOR,
+      transparent: true,
+      opacity: 0.7
+    });
+    const pointMesh = new THREE.Mesh(pointGeo, pointMat);
+    pointMesh.userData = { type: 'session_room_point', sessionId: session.id };
+    pointMesh.visible = false;  // starts hidden; shown only at LOD distance
+    group.add(pointMesh);
+
+    // Timestamp billboard sprite
+    const sprite = _makeTimestampSprite(session.timestamp, session.facts.length);
+    sprite.position.set(0, ROOM_HALF + 1.2, 0);
+    group.add(sprite);
+
+    // Inner ambient glow
+    const glow = new THREE.PointLight(ROOM_COLOR, 0.4, ROOM_SIZE * 1.2);
+    group.add(glow);
+
+    _scene.add(group);
+
+    const room = {
+      session,
+      group,
+      wireframe,
+      hitMesh,
+      pointMesh,
+      sprite,
+      glow,
+      pos: pos.clone(),
+      index,
+      lodActive: false,
+      pulsePhase: Math.random() * Math.PI * 2
+    };
+
+    _rooms.push(room);
+    _sessionIndex[session.id] = room;
+
+    console.info('[SessionRooms] Created room for session', session.id, 'at index', index);
+    return room;
+  }
+
+  // ─── TIMESTAMP SPRITE ────────────────────────────────
+  function _makeTimestampSprite(isoTimestamp, factCount) {
+    const canvas  = document.createElement('canvas');
+    canvas.width  = 320;
+    canvas.height = 72;
+    const ctx = canvas.getContext('2d');
+
+    // Background pill
+    ctx.clearRect(0, 0, 320, 72);
+    ctx.fillStyle = 'rgba(20, 10, 40, 0.82)';
+    _roundRect(ctx, 4, 4, 312, 64, 14);
+    ctx.fill();
+
+    // Border
+    ctx.strokeStyle = 'rgba(123, 92, 255, 0.6)';
+    ctx.lineWidth = 1.5;
+    _roundRect(ctx, 4, 4, 312, 64, 14);
+    ctx.stroke();
+
+    // Timestamp text
+    const dt = isoTimestamp ? new Date(isoTimestamp) : new Date();
+    const label = _formatDate(dt);
+    ctx.fillStyle = LABEL_COLOR;
+    ctx.font = 'bold 15px monospace';
+    ctx.textAlign = 'center';
+    ctx.fillText(label, 160, 30);
+
+    // Fact count
+    ctx.fillStyle = 'rgba(200, 180, 255, 0.65)';
+    ctx.font = '12px monospace';
+    ctx.fillText(factCount + (factCount === 1 ? ' fact' : ' facts'), 160, 52);
+
+    const tex    = new THREE.CanvasTexture(canvas);
+    const mat    = new THREE.SpriteMaterial({ map: tex, transparent: true, opacity: 0.88 });
+    const sprite = new THREE.Sprite(mat);
+    sprite.scale.set(5, 1.1, 1);
+    sprite.userData = { type: 'session_room_label' };
+    return sprite;
+  }
+
+  // ─── HELPERS ──────────────────────────────────────────
+  function _roundRect(ctx, x, y, w, h, r) {
+    ctx.beginPath();
+    ctx.moveTo(x + r, y);
+    ctx.lineTo(x + w - r, y);
+    ctx.quadraticCurveTo(x + w, y, x + w, y + r);
+    ctx.lineTo(x + w, y + h - r);
+    ctx.quadraticCurveTo(x + w, y + h, x + w - r, y + h);
+    ctx.lineTo(x + r, y + h);
+    ctx.quadraticCurveTo(x, y + h, x, y + h - r);
+    ctx.lineTo(x, y + r);
+    ctx.quadraticCurveTo(x, y, x + r, y);
+    ctx.closePath();
+  }
+
+  function _formatDate(dt) {
+    if (isNaN(dt.getTime())) return 'Unknown session';
+    const pad = n => String(n).padStart(2, '0');
+    return `${dt.getFullYear()}-${pad(dt.getMonth() + 1)}-${pad(dt.getDate())}  ${pad(dt.getHours())}:${pad(dt.getMinutes())}`;
+  }
+
+  // ─── DISPOSE ROOM ────────────────────────────────────
+  function _disposeRoom(room) {
+    room.wireframe.geometry.dispose();
+    room.wireframe.material.dispose();
+    room.hitMesh.geometry.dispose();
+    room.hitMesh.material.dispose();
+    room.pointMesh.geometry.dispose();
+    room.pointMesh.material.dispose();
+    if (room.sprite.material.map) room.sprite.material.map.dispose();
+    room.sprite.material.dispose();
+    if (room.group.parent) room.group.parent.remove(room.group);
+    delete _sessionIndex[room.session.id];
+  }
+
+  // ─── PUBLIC: UPDATE SESSIONS ─────────────────────────
+  // sessions: [{id, timestamp, facts:[{id,content,category,strength,...}]}]
+  // Sorted chronologically oldest→newest; max MAX_ROOMS shown.
+  function updateSessions(sessions) {
+    if (!_scene) return;
+
+    const sorted = [...sessions]
+      .sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp))
+      .slice(-MAX_ROOMS);  // keep most recent MAX_ROOMS
+
+    // Remove rooms no longer present
+    const incoming = new Set(sorted.map(s => s.id));
+    for (let i = _rooms.length - 1; i >= 0; i--) {
+      const room = _rooms[i];
+      if (!incoming.has(room.session.id)) {
+        _disposeRoom(room);
+        _rooms.splice(i, 1);
+      }
+    }
+
+    // Add / update
+    sorted.forEach((session, idx) => {
+      if (_sessionIndex[session.id]) {
+        // Update position if index changed
+        const room = _sessionIndex[session.id];
+        if (room.index !== idx) {
+          room.index = idx;
+          const newPos = _spiralPos(idx);
+          room.group.position.copy(newPos);
+          room.pos.copy(newPos);
+        }
+      } else {
+        _createRoom(session, idx);
+      }
+    });
+
+    saveToStorage(sorted);
+    console.info('[SessionRooms] Updated:', _rooms.length, 'session rooms');
+  }
+
+  // ─── PUBLIC: INIT ─────────────────────────────────────
+  function init(scene, camera, controls) {
+    _scene    = scene;
+    _camera   = camera;
+    _controls = controls;
+    console.info('[SessionRooms] Initialized');
+
+    // Restore persisted sessions
+    const saved = loadFromStorage();
+    if (saved && saved.length > 0) {
+      updateSessions(saved);
+    }
+  }
+
+  // ─── PUBLIC: UPDATE (per-frame) ───────────────────────
+  function update(delta) {
+    if (!_scene || !_camera) return;
+
+    const camPos = _camera.position;
+
+    _rooms.forEach(room => {
+      const dist = camPos.distanceTo(room.pos);
+
+      // LOD toggle
+      const threshold = room.lodActive
+        ? LOD_THRESHOLD + LOD_HYSTERESIS   // must come closer to exit LOD
+        : LOD_THRESHOLD;
+
+      if (dist > threshold && !room.lodActive) {
+        room.lodActive = true;
+        room.wireframe.visible = false;
+        room.sprite.visible    = false;
+        room.pointMesh.visible = true;
+      } else if (dist <= threshold && room.lodActive) {
+        room.lodActive = false;
+        room.wireframe.visible = true;
+        room.sprite.visible    = true;
+        room.pointMesh.visible = false;
+      }
+
+      // Pulse wireframe opacity
+      room.pulsePhase += delta * 0.6;
+      if (!room.lodActive) {
+        room.wireframe.material.opacity = 0.3 + Math.sin(room.pulsePhase) * 0.2;
+        room.glow.intensity = 0.3 + Math.sin(room.pulsePhase * 1.4) * 0.15;
+      }
+
+      // Slowly rotate each room
+      room.group.rotation.y += delta * 0.04;
+    });
+
+    // Fly-in tween
+    if (_flyActive) {
+      _flyElapsed += delta;
+      const t = Math.min(_flyElapsed / FLY_DURATION, 1);
+      const ease = _easeInOut(t);
+
+      _camera.position.lerpVectors(_flyFrom, _flyTo, ease);
+
+      // Interpolate lookAt
+      const lookNow = new THREE.Vector3().lerpVectors(_flyLookFrom, _flyLookTo, ease);
+      _camera.lookAt(lookNow);
+      if (_controls && _controls.target) _controls.target.copy(lookNow);
+
+      if (t >= 1) {
+        _flyActive = false;
+        if (_controls && typeof _controls.update === 'function') _controls.update();
+        console.info('[SessionRooms] Fly-in complete for session', _flyActiveRoom && _flyActiveRoom.session.id);
+        _flyActiveRoom = null;
+      }
+    }
+  }
+
+  // ─── EASING ───────────────────────────────────────────
+  function _easeInOut(t) {
+    return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+  }
+
+  // ─── PUBLIC: GET CLICKABLE MESHES ─────────────────────
+  function getClickableMeshes() {
+    return _rooms.map(r => r.hitMesh);
+  }
+
+  // ─── PUBLIC: HANDLE ROOM CLICK ────────────────────────
+  function handleRoomClick(mesh) {
+    const { sessionId } = mesh.userData;
+    const room = _sessionIndex[sessionId];
+    if (!room || !_camera) return null;
+
+    // Fly into the room from the front face
+    _flyActive   = true;
+    _flyElapsed  = 0;
+    _flyActiveRoom = room;
+
+    _flyFrom = _camera.position.clone();
+
+    // Target: step inside the room toward its center
+    const dir = room.pos.clone().sub(_camera.position).normalize();
+    _flyTo = room.pos.clone().add(dir.multiplyScalar(FLY_TARGET_DEPTH));
+
+    _flyLookFrom = _controls && _controls.target
+      ? _controls.target.clone()
+      : _camera.position.clone().add(_camera.getWorldDirection(new THREE.Vector3()));
+    _flyLookTo = room.pos.clone();
+
+    console.info('[SessionRooms] Flying into session room:', sessionId);
+    return room.session;
+  }
+
+  // ─── PERSISTENCE ──────────────────────────────────────
+  function saveToStorage(sessions) {
+    if (typeof localStorage === 'undefined') return;
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify({ v: 1, sessions }));
+    } catch (e) {
+      console.warn('[SessionRooms] Failed to save to localStorage:', e);
+    }
+  }
+
+  function loadFromStorage() {
+    if (typeof localStorage === 'undefined') return null;
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (!parsed || parsed.v !== 1 || !Array.isArray(parsed.sessions)) return null;
+      console.info('[SessionRooms] Restored', parsed.sessions.length, 'sessions from localStorage');
+      return parsed.sessions;
+    } catch (e) {
+      console.warn('[SessionRooms] Failed to load from localStorage:', e);
+      return null;
+    }
+  }
+
+  function clearStorage() {
+    if (typeof localStorage !== 'undefined') {
+      localStorage.removeItem(STORAGE_KEY);
+      console.info('[SessionRooms] Cleared localStorage');
+    }
+  }
+
+  // ─── PUBLIC API ───────────────────────────────────────
+  return {
+    init,
+    updateSessions,
+    update,
+    getClickableMeshes,
+    handleRoomClick,
+    clearStorage,
+    // For external inspection
+    getRooms: () => _rooms,
+    getSession: (id) => _sessionIndex[id] || null,
+    isFlyActive: () => _flyActive
+  };
+
+})();
+
+export { SessionRooms };

nexus/components/spatial-memory.js

@@ -8,12 +8,20 @@
 // holographic archive.
 //
 // World layout (hex cylinder, radius 25):
-//   North (z-)  → Documents & Knowledge
-//   South (z+)  → Projects & Tasks
-//   East  (x+)  → Code & Engineering
-//   West  (x-)  → Conversations & Social
-//   Center      → Active Working Memory
-//   Below (y-)  → Archive (cold storage)
+//
+//   Inner ring — original Mnemosyne taxonomy (radius 15):
+//     North (z-)  → Documents & Knowledge
+//     South (z+)  → Projects & Tasks
+//     East  (x+)  → Code & Engineering
+//     West  (x-)  → Conversations & Social
+//     Center      → Active Working Memory
+//     Below (y-)  → Archive (cold storage)
+//
+//   Outer ring — MemPalace category zones (radius 20, issue #1168):
+//     North (z-)  → User Preferences   [golden]
+//     East  (x+)  → Project facts      [blue]
+//     South (z+)  → Tool knowledge     [green]
+//     West  (x-)  → General facts      [gray]
 //
 // Usage from app.js:
 //   SpatialMemory.init(scene);
@@ -73,6 +81,44 @@ const SpatialMemory = (() => {
       color: 0x334455,
       glyph: '\uD83D\uDDC4',
       description: 'Cold storage — rarely accessed, aged-out memories'
+    },
+
+    // ── MemPalace category zones — outer ring, issue #1168 ────────────
+    user_pref: {
+      label: 'User Preferences',
+      center: [0, 0, -20],
+      radius: 10,
+      color: 0xffd700,
+      glyph: '\u2605',
+      description: 'Personal preferences, habits, user-specific settings',
+      labelY: 5
+    },
+    project: {
+      label: 'Project Facts',
+      center: [20, 0, 0],
+      radius: 10,
+      color: 0x4488ff,
+      glyph: '\uD83D\uDCC1',
+      description: 'Project-specific knowledge, goals, context',
+      labelY: 5
+    },
+    tool: {
+      label: 'Tool Knowledge',
+      center: [0, 0, 20],
+      radius: 10,
+      color: 0x44cc66,
+      glyph: '\uD83D\uDD27',
+      description: 'Tools, commands, APIs, and how to use them',
+      labelY: 5
+    },
+    general: {
+      label: 'General Facts',
+      center: [-20, 0, 0],
+      radius: 10,
+      color: 0x8899aa,
+      glyph: '\uD83D\uDCDD',
+      description: 'Miscellaneous facts not fitting other categories',
+      labelY: 5
     }
   };
 
@@ -99,6 +145,7 @@ const SpatialMemory = (() => {
     const cx = region.center[0];
     const cy = region.center[1] + 0.06;
     const cz = region.center[2];
+    const labelY = region.labelY || 3;
 
     const ringGeo = new THREE.RingGeometry(region.radius - 0.5, region.radius, 6);
     const ringMat = new THREE.MeshBasicMaterial({
@@ -126,6 +173,22 @@ const SpatialMemory = (() => {
     _scene.add(ring);
     _scene.add(disc);
 
+    // Ground glow — brighter disc for MemPalace zones (labelY > 3 signals outer ring)
+    let glowDisc = null;
+    if (labelY > 3) {
+      const glowGeo = new THREE.CircleGeometry(region.radius, 32);
+      const glowMat = new THREE.MeshBasicMaterial({
+        color: region.color,
+        transparent: true,
+        opacity: 0.06,
+        side: THREE.DoubleSide
+      });
+      glowDisc = new THREE.Mesh(glowGeo, glowMat);
+      glowDisc.rotation.x = -Math.PI / 2;
+      glowDisc.position.set(cx, cy - 0.02, cz);
+      _scene.add(glowDisc);
+    }
+
     // Floating label
     const canvas = document.createElement('canvas');
     canvas.width = 256;
@@ -139,11 +202,11 @@ const SpatialMemory = (() => {
     const texture = new THREE.CanvasTexture(canvas);
     const spriteMat = new THREE.SpriteMaterial({ map: texture, transparent: true, opacity: 0.6 });
     const sprite = new THREE.Sprite(spriteMat);
-    sprite.position.set(cx, 3, cz);
+    sprite.position.set(cx, labelY, cz);
     sprite.scale.set(4, 1, 1);
     _scene.add(sprite);
 
-    return { ring, disc, sprite };
+    return { ring, disc, glowDisc, sprite };
   }
 
   // ─── PLACE A MEMORY ──────────────────────────────────
@@ -283,6 +346,9 @@ const SpatialMemory = (() => {
       if (marker.ring && marker.ring.material) {
         marker.ring.material.opacity = 0.1 + Math.sin(now * 0.001) * 0.05;
       }
+      if (marker.glowDisc && marker.glowDisc.material) {
+        marker.glowDisc.material.opacity = 0.04 + Math.sin(now * 0.0008) * 0.02;
+      }
     });
   }
 

server.py

@@ -3,17 +3,156 @@
 The Nexus WebSocket Gateway — Robust broadcast bridge for Timmy's consciousness.
 This server acts as the central hub for the-nexus, connecting the mind (nexus_think.py),
 the body (Evennia/Morrowind), and the visualization surface.
+
+Serves HTTP alongside WebSocket:
+  GET /api/briefing  — heartbeat + morning report data for the HUD briefing panel
 """
 import asyncio
 import json
 import logging
+import os
 import signal
 import sys
-from typing import Set
+from datetime import datetime, timezone
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from pathlib import Path
+from threading import Thread
+from typing import Any, Dict, Set
 
 # Branch protected file - see POLICY.md
 import websockets
 
+
+# ── HTTP Briefing Endpoint ─────────────────────────────────────────────
+
+HEARTBEAT_PATH = Path.home() / ".nexus" / "heartbeat.json"
+REPORTS_DIR = Path.home() / ".local" / "timmy" / "reports"
+CRON_HEARTBEAT_DIR_PRIMARY = Path("/var/run/bezalel/heartbeats")
+CRON_HEARTBEAT_DIR_FALLBACK = Path.home() / ".bezalel" / "heartbeats"
+
+
+def _read_json_file(path: Path) -> Any:
+    """Read and parse a JSON file. Returns None on failure."""
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _resolve_cron_dir() -> Path:
+    """Return the first writable cron heartbeat directory."""
+    for d in [CRON_HEARTBEAT_DIR_PRIMARY, CRON_HEARTBEAT_DIR_FALLBACK]:
+        if d.exists() and os.access(str(d), os.R_OK):
+            return d
+    return CRON_HEARTBEAT_DIR_FALLBACK
+
+
+def _read_cron_heartbeats() -> list:
+    """Read all .last files from the cron heartbeat directory."""
+    hb_dir = _resolve_cron_dir()
+    if not hb_dir.exists():
+        return []
+    now = datetime.now(timezone.utc).timestamp()
+    jobs = []
+    for f in sorted(hb_dir.glob("*.last")):
+        data = _read_json_file(f)
+        if data is None:
+            jobs.append({"job": f.stem, "healthy": False, "message": "corrupt"})
+            continue
+        ts = float(data.get("timestamp", 0))
+        interval = int(data.get("interval", 3600))
+        age = now - ts
+        is_stale = age > (2 * interval)
+        jobs.append({
+            "job": f.stem,
+            "healthy": not is_stale,
+            "age_secs": round(age, 1),
+            "interval": interval,
+            "last_seen": datetime.fromtimestamp(ts, tz=timezone.utc).isoformat() if ts else None,
+            "message": f"{'STALE' if is_stale else 'OK'} ({age:.0f}s / {interval}s)" if ts else "no timestamp",
+        })
+    return jobs
+
+
+def _latest_morning_report() -> Dict[str, Any] | None:
+    """Find the most recent morning report file."""
+    if not REPORTS_DIR.exists():
+        return None
+    reports = sorted(REPORTS_DIR.glob("morning-*.json"), reverse=True)
+    if not reports:
+        return None
+    return _read_json_file(reports[0])
+
+
+def _build_briefing() -> Dict[str, Any]:
+    """Assemble the full briefing payload from real files."""
+    now = datetime.now(timezone.utc)
+
+    # Core heartbeat
+    core_hb = _read_json_file(HEARTBEAT_PATH)
+    if core_hb:
+        beat_ts = float(core_hb.get("timestamp", 0))
+        core_hb["age_secs"] = round(now.timestamp() - beat_ts, 1) if beat_ts else None
+
+    # Cron heartbeats
+    cron_jobs = _read_cron_heartbeats()
+    healthy_count = sum(1 for j in cron_jobs if j.get("healthy"))
+    stale_count = sum(1 for j in cron_jobs if not j.get("healthy"))
+
+    # Morning report
+    report = _latest_morning_report()
+
+    return {
+        "generated_at": now.isoformat(),
+        "core_heartbeat": core_hb,
+        "cron_heartbeat": {
+            "jobs": cron_jobs,
+            "healthy_count": healthy_count,
+            "stale_count": stale_count,
+        },
+        "morning_report": report,
+    }
+
+
+class BriefingHandler(SimpleHTTPRequestHandler):
+    """Minimal HTTP handler that only serves /api/briefing."""
+
+    def do_GET(self):
+        if self.path == "/api/briefing":
+            try:
+                data = _build_briefing()
+                body = json.dumps(data).encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.send_header("Access-Control-Allow-Origin", "*")
+                self.end_headers()
+                self.wfile.write(body)
+            except Exception as e:
+                self.send_error(500, str(e))
+        elif self.path == "/api/health":
+            body = json.dumps({"status": "ok"}).encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.end_headers()
+            self.wfile.write(body)
+        else:
+            self.send_error(404)
+
+    def log_message(self, fmt, *args):
+        pass  # Suppress HTTP access logs — WS gateway logs are enough
+
+
+def start_http_server(port: int = 8766):
+    """Run the HTTP server in a daemon thread."""
+    server = HTTPServer(("0.0.0.0", port), BriefingHandler)
+    thread = Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    logger = logging.getLogger("nexus-gateway")
+    logger.info(f"Briefing HTTP server started on http://0.0.0.0:{port}")
+    return server
+
 # Configuration
 PORT = 8765
 HOST = "0.0.0.0"  # Allow external connections if needed
@@ -80,6 +219,9 @@ async def broadcast_handler(websocket: websockets.WebSocketServerProtocol):
 
 async def main():
     """Main server loop with graceful shutdown."""
+    # Start HTTP briefing endpoint alongside WS
+    http_server = start_http_server(port=8766)
+
     logger.info(f"Starting Nexus WS gateway on ws://{HOST}:{PORT}")
     
     # Set up signal handlers for graceful shutdown

style.css

@@ -1224,6 +1224,138 @@ canvas#nexus-canvas {
 
 .pse-status { color: #4af0c0; font-weight: 600; }
 
+/* ═══ HEARTBEAT BRIEFING PANEL ═════════════════════════════════════ */
+.hud-panel-briefing {
+  width: 320px;
+  max-height: 420px;
+  border-left-color: #7b5cff;
+}
+.hud-panel-briefing .panel-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  color: #7b5cff;
+}
+.hud-panel-briefing .panel-content {
+  max-height: 360px;
+  overflow-y: auto;
+}
+/* Pulse dot */
+.hb-pulse-dot {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: #4af0c0;
+  box-shadow: 0 0 6px #4af0c0;
+  animation: hb-dot-pulse 2s ease-in-out infinite;
+  flex-shrink: 0;
+}
+.hb-pulse-dot.offline {
+  background: #ff4466;
+  box-shadow: 0 0 6px #ff4466;
+  animation: none;
+}
+@keyframes hb-dot-pulse {
+  0%, 100% { opacity: 0.4; }
+  50%       { opacity: 1; }
+}
+/* Briefing sections */
+.briefing-section {
+  margin-bottom: 8px;
+  padding-bottom: 6px;
+  border-bottom: 1px solid rgba(123, 92, 255, 0.12);
+}
+.briefing-section:last-child { border-bottom: none; margin-bottom: 0; }
+.briefing-section-label {
+  font-size: 9px;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: #8a9ab8;
+  margin-bottom: 4px;
+}
+/* Core heartbeat row */
+.hb-core-row {
+  display: flex;
+  gap: 10px;
+  align-items: center;
+  margin-bottom: 4px;
+}
+.hb-core-status {
+  font-weight: 700;
+  font-size: 11px;
+}
+.hb-core-status.alive { color: #4af0c0; }
+.hb-core-status.dead  { color: #ff4466; }
+.hb-core-meta {
+  font-size: 10px;
+  color: #8a9ab8;
+}
+/* Cron jobs */
+.hb-cron-row {
+  display: flex;
+  gap: 8px;
+  font-size: 10px;
+  margin-bottom: 2px;
+}
+.hb-cron-healthy { color: #4af0c0; }
+.hb-cron-stale   { color: #ff4466; font-weight: 700; }
+.hb-cron-job {
+  display: flex;
+  justify-content: space-between;
+  font-size: 10px;
+  padding: 1px 0;
+}
+.hb-cron-job-name { color: #e0f0ff; }
+.hb-cron-job-status.healthy { color: #4af0c0; }
+.hb-cron-job-status.stale   { color: #ff4466; font-weight: 700; }
+/* Morning report stats */
+.hb-stats-row {
+  display: flex;
+  gap: 12px;
+  font-size: 10px;
+}
+.hb-stat {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+.hb-stat-value {
+  font-family: 'Orbitron', sans-serif;
+  font-weight: 700;
+  font-size: 14px;
+}
+.hb-stat-label {
+  font-size: 9px;
+  color: #8a9ab8;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+/* Blockers */
+.hb-blocker {
+  font-size: 10px;
+  color: #ff4466;
+  padding: 1px 0;
+}
+/* Narrative */
+.hb-narrative {
+  font-size: 10px;
+  color: #8a9ab8;
+  line-height: 1.5;
+  font-style: italic;
+}
+/* Empty / offline state */
+.hb-empty {
+  font-size: 10px;
+  color: #8a9ab8;
+  text-align: center;
+  padding: 12px 0;
+}
+/* Timestamp */
+.hb-timestamp {
+  font-size: 9px;
+  color: rgba(138, 154, 184, 0.6);
+  margin-top: 4px;
+}
 
 /* ═══════════════════════════════════════════
    MNEMOSYNE — MEMORY CRYSTAL INSPECTION PANEL
@@ -1461,3 +1593,122 @@ canvas#nexus-canvas {
   gap: 2px;
 }
 
+/* ═══════════════════════════════════════════════════════
+   PROJECT MNEMOSYNE — SESSION ROOM HUD PANEL (#1171)
+═══════════════════════════════════════════════════════ */
+
+.session-room-panel {
+  position: fixed;
+  bottom: 24px;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: 125;
+  animation: sessionPanelIn 0.25s ease-out forwards;
+}
+
+.session-room-panel.session-panel-fade-out {
+  animation: sessionPanelOut 0.2s ease-in forwards !important;
+}
+
+@keyframes sessionPanelIn {
+  from { opacity: 0; transform: translateX(-50%) translateY(12px); }
+  to   { opacity: 1; transform: translateX(-50%) translateY(0); }
+}
+
+@keyframes sessionPanelOut {
+  from { opacity: 1; }
+  to   { opacity: 0; transform: translateX(-50%) translateY(10px); }
+}
+
+.session-room-panel-content {
+  min-width: 320px;
+  max-width: 480px;
+  background: rgba(8, 4, 28, 0.93);
+  backdrop-filter: blur(14px);
+  border: 1px solid rgba(123, 92, 255, 0.35);
+  border-radius: 12px;
+  padding: 14px 18px;
+  box-shadow: 0 0 32px rgba(123, 92, 255, 0.1), 0 8px 32px rgba(0, 0, 0, 0.45);
+}
+
+.session-room-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 8px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.07);
+}
+
+.session-room-icon {
+  font-size: 14px;
+  line-height: 1;
+}
+
+.session-room-title {
+  font-family: var(--font-display, monospace);
+  font-size: 11px;
+  letter-spacing: 0.18em;
+  color: #9b7cff;
+  text-transform: uppercase;
+  flex: 1;
+}
+
+.session-room-close {
+  background: none;
+  border: none;
+  color: rgba(255, 255, 255, 0.35);
+  cursor: pointer;
+  font-size: 14px;
+  padding: 0 2px;
+  line-height: 1;
+  transition: color 0.15s;
+}
+
+.session-room-close:hover {
+  color: rgba(255, 255, 255, 0.8);
+}
+
+.session-room-timestamp {
+  font-family: var(--font-display, monospace);
+  font-size: 13px;
+  color: #c8b4ff;
+  margin-bottom: 6px;
+  letter-spacing: 0.08em;
+}
+
+.session-room-fact-count {
+  font-size: 11px;
+  color: rgba(200, 180, 255, 0.55);
+  margin-bottom: 10px;
+}
+
+.session-room-facts {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  max-height: 140px;
+  overflow-y: auto;
+}
+
+.session-room-fact-item {
+  font-size: 11px;
+  color: rgba(220, 210, 255, 0.75);
+  padding: 4px 8px;
+  background: rgba(123, 92, 255, 0.07);
+  border-left: 2px solid rgba(123, 92, 255, 0.4);
+  border-radius: 0 4px 4px 0;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.session-room-hint {
+  margin-top: 10px;
+  font-size: 10px;
+  color: rgba(200, 180, 255, 0.35);
+  text-align: center;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+}
+