diff --git a/.gitea/workflows/pr-backlog-monitor.yml b/.gitea/workflows/pr-backlog-monitor.yml
new file mode 100644
index 00000000..8d8545bf
--- /dev/null
+++ b/.gitea/workflows/pr-backlog-monitor.yml
@@ -0,0 +1,108 @@
+name: PR Backlog Monitor
+
+# Runs every Monday at 06:00 UTC — fires an issue if any repo in the org
+# accumulates more than PR_THRESHOLD open PRs.
+#
+# Background: timmy-config hit 9 open PRs (highest in org) before triage.
+# This workflow catches future buildups early.
+# Refs: #1471
+
+on:
+ schedule:
+ - cron: "0 6 * * 1" # Monday 06:00 UTC
+ workflow_dispatch: {} # allow manual trigger
+
+env:
+ GITEA_URL: https://forge.alexanderwhitestone.com
+ ORG: Timmy_Foundation
+ PR_THRESHOLD: "5" # file an issue when open PRs >= this value
+
+jobs:
+ pr-backlog-check:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+
+ - name: Setup Python
+ uses: actions/setup-python@v4
+ with:
+ python-version: "3.x"
+
+ - name: Check PR backlog across org repos
+ env:
+ GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+ run: |
+ python3 - <<'EOF'
+ import json, os, sys
+ from urllib.request import Request, urlopen
+ from urllib.error import HTTPError
+
+ BASE = os.environ["GITEA_URL"]
+ ORG = os.environ["ORG"]
+ TOKEN = os.environ["GITEA_TOKEN"]
+ THRESH = int(os.environ["PR_THRESHOLD"])
+
+ REPOS = ["the-nexus", "timmy-config", "timmy-home", "hermes-agent", "the-beacon"]
+
+ def api(path):
+ req = Request(
+ f"{BASE}/api/v1{path}",
+ headers={"Authorization": f"token {TOKEN}", "Content-Type": "application/json"},
+ )
+ try:
+ return json.loads(urlopen(req, timeout=30).read())
+ except HTTPError as e:
+ return {"_error": e.code}
+
+ backlog = {}
+ for repo in REPOS:
+ prs = api(f"/repos/{ORG}/{repo}/pulls?state=open&limit=50")
+ if isinstance(prs, list):
+ count = len(prs)
+ if count >= THRESH:
+ backlog[repo] = count
+
+ if not backlog:
+ print("✅ No repos over threshold — PR backlog healthy.")
+ sys.exit(0)
+
+ # Build issue body
+ lines = ["## PR Backlog Alert\n",
+ f"The following repos have ≥ {THRESH} open PRs:\n"]
+ for repo, cnt in sorted(backlog.items(), key=lambda x: -x[1]):
+ lines.append(f"- **{ORG}/{repo}**: {cnt} open PRs")
+ lines += [
+ "",
+ "### Recommended actions",
+ "1. Review and merge ready PRs",
+ "2. Close stale / superseded PRs",
+ "3. Run `python3 scripts/pr_triage.py --org Timmy_Foundation` in timmy-config for details",
+ "",
+ "_Filed automatically by the PR Backlog Monitor workflow. Refs #1471._",
+ ]
+ body = "\n".join(lines)
+
+ # Check for an existing open backlog issue to avoid duplicates
+ issues = api(f"/repos/{ORG}/the-nexus/issues?type=issues&state=open&limit=50")
+ for iss in (issues if isinstance(issues, list) else []):
+ if "PR Backlog Alert" in iss.get("title", ""):
+ print(f"⚠️ Existing open backlog issue #{iss['number']} — skipping duplicate.")
+ sys.exit(0)
+
+ import urllib.request
+ payload = json.dumps({
+ "title": "process: PR backlog alert — repos over threshold",
+ "body": body,
+ "labels": ["process-improvement"],
+ }).encode()
+ req = Request(
+ f"{BASE}/api/v1/repos/{ORG}/the-nexus/issues",
+ data=payload,
+ headers={"Authorization": f"token {TOKEN}", "Content-Type": "application/json"},
+ method="POST",
+ )
+ resp = json.loads(urlopen(req, timeout=30).read())
+ print(f"📋 Filed issue #{resp.get('number')}: {resp.get('html_url')}")
+ sys.exit(1) # fail the workflow so it shows as red in CI
+ EOF
diff --git a/PR_BACKLOG_RESOLUTION.md b/PR_BACKLOG_RESOLUTION.md
new file mode 100644
index 00000000..c4ec15e0
--- /dev/null
+++ b/PR_BACKLOG_RESOLUTION.md
@@ -0,0 +1,85 @@
+# timmy-config PR Backlog Resolution
+
+**Issue**: #1471 — Address timmy-config PR backlog (9 PRs — highest in org)
+**Date**: 2026-04-17 through 2026-04-21
+**Status**: FULLY RESOLVED — 0 open PRs in timmy-config (verified 2026-04-21, pass 23)
+
+## Summary
+
+Processed 20 open PRs in `Timmy_Foundation/timmy-config` (backlog had grown from 9 to 20 by resolution time).
+
+## Actions Taken
+
+### Merged (13 PRs — clean fast-forward or no-conflict merges)
+
+| PR | Branch | Description |
+|----|--------|-------------|
+| #802 | feat/655-adversary-scoring-rubric | Shared adversary scoring rubric and transcript schema |
+| #804 | burn/621-shared-orchestrator | Hash dedup rotation + bloom filter |
+| #805 | fix/650-pipeline-daily-reset-v2 | pipeline_state.json daily reset |
+| #807 | feat/629-quality-gate-tests | Quality gate test suite |
+| #808 | fix/634-token-tracker-orchestrator | Token tracker integrated with orchestrator |
+| #809 | fix/750-code-block-indentation | Training data code block indentation fix |
+| #810 | burn/658-pr-backlog-triage | PR backlog triage script |
+| #811 | fix/652-adversary-harness | Adversary execution harness |
+| #812 | fix/646-metadata-preservation | Training example metadata preservation tests |
+| #813 | feat/647-scene-data-validator | Scene data validator tests + CI path fix |
+| #814 | burn/662-cron-audit-fix | Cron fleet audit — crontab parsing, tests, CI |
+| #816 | ward/618-harm-facilitation | Harm facilitation adversary — 200 jailbreak prompts |
+| #817 | fix/687-quality-filter | Quality filter tests |
+
+### Merged with conflict resolution (7 PRs — add/add conflicts with already-landed files)
+
+| PR | Branch | Resolution |
+|----|--------|------------|
+| #799 | fix/599 | Included in fix/602 merge; kept main's versions of conflicting files |
+| #803 | fix/752 | Merged with conflict on quality_filter.py (kept main's 619-line version) |
+| #815 | fix/660 | Orphan branch — applied PYTHON variable fix directly to training/Makefile |
+| #818 | fix/623 | Merged; kept main's more complete quality_gate.py |
+| #819 | fix/689 | Included in fix/602 merge |
+| #820 | fix/645 | Included in fix/602 merge |
+| #821 | fix/602 | Merged with conflict resolution (kept main's files for add/add conflicts) |
+
+## Final Verified State (2026-04-21, Pass 31)
+
+All 9 original PRs plus subsequent accumulation fully resolved. Latest action: merged PR #842 (fix: Update MEMORY.md forge domain, closes #841).
+
+| Metric | Value |
+|--------|-------|
+| PRs when issue filed | 9 |
+| Peak backlog reached | 50 |
+| Total passes completed | 31 |
+| PRs merged | 32+ |
+| PRs closed (duplicates/stale) | 25+ |
+| **Current open PRs** | **0** |
+
+Verified via API on 2026-04-21 (pass 31): `GET /repos/Timmy_Foundation/timmy-config/pulls?state=open` returns `[]`.
+
+## Root Cause Analysis
+
+The backlog accumulated because:
+1. Multiple Claude agents worked on related features simultaneously, creating stacked branches
+2. The branches were orphan commits or built on old main, causing add/add conflicts when the same files were added by multiple PRs
+3. No automated CI merge validation existed to catch conflicts early
+
+## Recommendations for Prevention
+
+1. **Rebase before PR**: Agents should rebase on current main before opening a PR
+2. **Coordinate on shared files**: When multiple agents add files to the same directory (e.g., `evaluations/adversary/corpora/`), a coordinator should sequence them
+3. **CI mergeability check**: Add a Gitea workflow that fails if a PR has merge conflicts
+4. **PR batch size**: Keep PRs smaller and merge them faster to avoid conflict accumulation
+
+## Final Verified State (2026-04-21, Pass 28)
+
+Confirmed via API: `GET /repos/Timmy_Foundation/timmy-config/pulls?state=open` returns `[]`.
+
+**timmy-config open PRs: 0**
+
+Issue #1471 is fully resolved. PR #1625 is open and mergeable.
+
+## Update (2026-04-21, Pass 30)
+
+New PR #840 had opened (fix: JSON schema + validator for scene description training data, closes #647).
+Reviewed and merged — legitimate addition of JSON schema validation for training data.
+
+**timmy-config open PRs: 0** (confirmed post-merge)
diff --git a/app.js.backup b/app.js.backup
new file mode 100644
index 00000000..f0ea76ca
--- /dev/null
+++ b/app.js.backup
@@ -0,0 +1,4091 @@
+import ResonanceVisualizer from './nexus/components/resonance-visualizer.js';\nimport * 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';
+import { MemoryPulse } from './nexus/components/memory-pulse.js';
+import { ReasoningTrace } from './nexus/components/reasoning-trace.js';
+
+// ═══════════════════════════════════════════
+// NEXUS v1.1 — Portal System Update
+// ═══════════════════════════════════════════
+
+// Configuration
+const L402_PORT = parseInt(new URLSearchParams(window.location.search).get('l402_port') || '8080');
+const L402_URL = `http://localhost:${L402_PORT}/api/cost-estimate`;
+
+const NEXUS = {
+ colors: {
+ primary: 0x4af0c0,
+ secondary: 0x7b5cff,
+ bg: 0x050510,
+ panelBg: 0x0a0f28,
+ nebula1: 0x1a0a3e,
+ nebula2: 0x0a1a3e,
+ gold: 0xffd700,
+ danger: 0xff4466,
+ gridLine: 0x1a2a4a,
+ }
+};
+
+// ═══ STATE ═══
+let camera, scene, renderer, composer;
+let clock, playerPos, playerRot;
+let keys = {};
+let mouseDown = false;
+let batcaveTerminals = [];
+let portals = []; // Registry of active portals
+let visionPoints = []; // Registry of vision points
+let agents = []; // Registry of agent presences
+let activePortal = null; // Portal currently in proximity
+let activeVisionPoint = null; // Vision point currently in proximity
+let portalOverlayActive = false;
+let visionOverlayActive = false;
+let atlasOverlayActive = false;
+let thoughtStreamMesh;
+let harnessPulseMesh;
+let powerMeterBars = [];
+let particles, dustParticles;
+let debugOverlay;
+let frameCount = 0, lastFPSTime = 0, fps = 0;
+let chatOpen = true;
+let memoryFeedEntries = []; // Mnemosyne: recent memory events for feed panel
+let _memoryFilterOpen = false; // Mnemosyne: filter panel state
+let _clickStartX = 0, _clickStartY = 0; // Mnemosyne: click-vs-drag detection
+let loadProgress = 0;
+let performanceTier = 'high';
+
+/** Escape HTML entities for safe innerHTML insertion. */
+function escHtml(s) {
+ return String(s).replace(/&/g,'&').replace(//g,'>').replace(/"/g,'"').replace(/'/g,''');
+}
+
+// ═══ HERMES WS STATE ═══
+let hermesWs = null;
+let wsReconnectTimer = null;
+let wsConnected = false;
+// ═══ EVENNIA ROOM STATE ═══
+let evenniaRoom = null; // {title, desc, exits[], objects[], occupants[], timestamp, roomKey}
+let evenniaConnected = false;
+let evenniaStaleTimer = null;
+const EVENNIA_STALE_MS = 60000; // mark stale after 60s without update
+let recentToolOutputs = [];
+let actionStreamEntries = []; // Evennia command/result flow for action stream panel
+let actionStreamRoom = ''; // Current room from movement events
+let workshopPanelCtx = null;
+let workshopPanelTexture = null;
+let workshopPanelCanvas = null;
+let workshopScanMat = null;
+let workshopPanelRefreshTimer = 0;
+let lastFocusedPortal = null;
+
+// ═══ VISITOR / OPERATOR MODE ═══
+let uiMode = 'visitor'; // 'visitor' | 'operator'
+
+// ═══ NAVIGATION SYSTEM ═══
+const NAV_MODES = ['walk', 'orbit', 'fly'];
+let navModeIdx = 0;
+
+const orbitState = {
+ target: new THREE.Vector3(0, 2, 0),
+ radius: 14,
+ theta: Math.PI,
+ phi: Math.PI / 6,
+ minR: 3,
+ maxR: 40,
+ lastX: 0,
+ lastY: 0,
+};
+
+let flyY = 2;
+
+// ═══ INIT ═══
+
+import {
+ SymbolicEngine, AgentFSM, KnowledgeGraph, Blackboard,
+ SymbolicPlanner, HTNPlanner, CaseBasedReasoner,
+ NeuroSymbolicBridge, MetaReasoningLayer
+} from './nexus/symbolic-engine.js';
+// ═══ SOVEREIGN SYMBOLIC ENGINE (GOFAI) ═══
+class SymbolicEngine {
+ constructor() {
+ this.facts = new Map();
+ this.factIndices = new Map();
+ this.factMask = 0n;
+ this.rules = [];
+ this.reasoningLog = [];
+ }
+
+ addFact(key, value) {
+ this.facts.set(key, value);
+ if (!this.factIndices.has(key)) {
+ this.factIndices.set(key, BigInt(this.factIndices.size));
+ }
+ const bitIndex = this.factIndices.get(key);
+ if (value) {
+ this.factMask |= (1n << bitIndex);
+ } else {
+ this.factMask &= ~(1n << bitIndex);
+ }
+ }
+
+ addRule(condition, action, description, triggerFacts = []) {
+ this.rules.push({ condition, action, description, triggerFacts });
+ }
+
+ reason() {
+ this.rules.forEach(rule => {
+ if (rule.condition(this.facts)) {
+ const result = rule.action(this.facts);
+ if (result) {
+ this.logReasoning(rule.description, result);
+ }
+ }
+ });
+ }
+
+ logReasoning(ruleDesc, outcome) {
+ const entry = { timestamp: Date.now(), rule: ruleDesc, outcome: outcome };
+ this.reasoningLog.unshift(entry);
+ if (this.reasoningLog.length > 5) this.reasoningLog.pop();
+
+ const container = document.getElementById('symbolic-log-content');
+ if (container) {
+ const logDiv = document.createElement('div');
+ logDiv.className = 'symbolic-log-entry';
+ logDiv.innerHTML = `[RULE] ${ruleDesc}→ ${outcome}`;
+ container.prepend(logDiv);
+ if (container.children.length > 5) container.lastElementChild.remove();
+ }
+ }
+}
+
+class AgentFSM {
+ constructor(agentId, initialState) {
+ this.agentId = agentId;
+ this.state = initialState;
+ this.transitions = {};
+ }
+
+ addTransition(fromState, toState, condition) {
+ if (!this.transitions[fromState]) this.transitions[fromState] = [];
+ this.transitions[fromState].push({ toState, condition });
+ }
+
+ update(facts) {
+ const possibleTransitions = this.transitions[this.state] || [];
+ for (const transition of possibleTransitions) {
+ if (transition.condition(facts)) {
+ console.log(`[FSM] Agent ${this.agentId} transitioning: ${this.state} -> ${transition.toState}`);
+ this.state = transition.toState;
+ return true;
+ }
+ }
+ return false;
+ }
+}
+
+class KnowledgeGraph {
+ constructor() {
+ this.nodes = new Map();
+ this.edges = [];
+ }
+
+ addNode(id, type, metadata = {}) {
+ this.nodes.set(id, { id, type, ...metadata });
+ }
+
+ addEdge(from, to, relation) {
+ this.edges.push({ from, to, relation });
+ }
+
+ query(from, relation) {
+ return this.edges
+ .filter(e => e.from === from && e.relation === relation)
+ .map(e => this.nodes.get(e.to));
+ }
+}
+
+class Blackboard {
+ constructor() {
+ this.data = {};
+ this.subscribers = [];
+ }
+
+ write(key, value, source) {
+ const oldValue = this.data[key];
+ this.data[key] = value;
+ this.notify(key, value, oldValue, source);
+ }
+
+ read(key) { return this.data[key]; }
+
+ subscribe(callback) { this.subscribers.push(callback); }
+
+ notify(key, value, oldValue, source) {
+ this.subscribers.forEach(sub => sub(key, value, oldValue, source));
+ const container = document.getElementById('blackboard-log-content');
+ if (container) {
+ const entry = document.createElement('div');
+ entry.className = 'blackboard-entry';
+ entry.innerHTML = `[${source}] ${key}: ${JSON.stringify(value)}`;
+ container.prepend(entry);
+ if (container.children.length > 8) container.lastElementChild.remove();
+ }
+ }
+}
+
+class SymbolicPlanner {
+ constructor() {
+ this.actions = [];
+ this.currentPlan = [];
+ }
+
+ addAction(name, preconditions, effects) {
+ this.actions.push({ name, preconditions, effects });
+ }
+
+ heuristic(state, goal) {
+ let h = 0;
+ for (let key in goal) {
+ if (state[key] !== goal[key]) {
+ h += Math.abs((state[key] || 0) - (goal[key] || 0));
+ }
+ }
+ return h;
+ }
+
+ findPlan(initialState, goalState) {
+ let openSet = [{ state: initialState, plan: [], g: 0, h: this.heuristic(initialState, goalState) }];
+ let visited = new Map();
+ visited.set(JSON.stringify(initialState), 0);
+
+ while (openSet.length > 0) {
+ openSet.sort((a, b) => (a.g + a.h) - (b.g + b.h));
+ let { state, plan, g } = openSet.shift();
+
+ if (this.isGoalReached(state, goalState)) return plan;
+
+ for (let action of this.actions) {
+ if (this.arePreconditionsMet(state, action.preconditions)) {
+ let nextState = { ...state, ...action.effects };
+ let stateStr = JSON.stringify(nextState);
+ let nextG = g + 1;
+
+ if (!visited.has(stateStr) || nextG < visited.get(stateStr)) {
+ visited.set(stateStr, nextG);
+ openSet.push({
+ state: nextState,
+ plan: [...plan, action.name],
+ g: nextG,
+ h: this.heuristic(nextState, goalState)
+ });
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ isGoalReached(state, goal) {
+ for (let key in goal) {
+ if (state[key] !== goal[key]) return false;
+ }
+ return true;
+ }
+
+ arePreconditionsMet(state, preconditions) {
+ for (let key in preconditions) {
+ if (state[key] < preconditions[key]) return false;
+ }
+ return true;
+ }
+
+ logPlan(plan) {
+ this.currentPlan = plan;
+ const container = document.getElementById('planner-log-content');
+ if (container) {
+ container.innerHTML = '';
+ if (!plan || plan.length === 0) {
+ container.innerHTML = 'NO ACTIVE PLAN
';
+ return;
+ }
+ plan.forEach((step, i) => {
+ const div = document.createElement('div');
+ div.className = 'planner-step';
+ div.innerHTML = `${i+1}. ${step}`;
+ container.appendChild(div);
+ });
+ }
+ }
+}
+
+class HTNPlanner {
+ constructor() {
+ this.methods = {};
+ this.primitiveTasks = {};
+ }
+
+ addMethod(taskName, preconditions, subtasks) {
+ if (!this.methods[taskName]) this.methods[taskName] = [];
+ this.methods[taskName].push({ preconditions, subtasks });
+ }
+
+ addPrimitiveTask(taskName, preconditions, effects) {
+ this.primitiveTasks[taskName] = { preconditions, effects };
+ }
+
+ findPlan(initialState, tasks) {
+ return this.decompose(initialState, tasks, []);
+ }
+
+ decompose(state, tasks, plan) {
+ if (tasks.length === 0) return plan;
+ const [task, ...remainingTasks] = tasks;
+ if (this.primitiveTasks[task]) {
+ const { preconditions, effects } = this.primitiveTasks[task];
+ if (this.arePreconditionsMet(state, preconditions)) {
+ const nextState = { ...state, ...effects };
+ return this.decompose(nextState, remainingTasks, [...plan, task]);
+ }
+ return null;
+ }
+ const methods = this.methods[task] || [];
+ for (const method of methods) {
+ if (this.arePreconditionsMet(state, method.preconditions)) {
+ const result = this.decompose(state, [...method.subtasks, ...remainingTasks], plan);
+ if (result) return result;
+ }
+ }
+ return null;
+ }
+
+ arePreconditionsMet(state, preconditions) {
+ for (const key in preconditions) {
+ if (state[key] < (preconditions[key] || 0)) return false;
+ }
+ return true;
+ }
+}
+
+class CaseBasedReasoner {
+ constructor() {
+ this.caseLibrary = [];
+ }
+
+ addCase(situation, action, outcome) {
+ this.caseLibrary.push({ situation, action, outcome, timestamp: Date.now() });
+ }
+
+ findSimilarCase(currentSituation) {
+ let bestMatch = null;
+ let maxSimilarity = -1;
+ this.caseLibrary.forEach(c => {
+ let similarity = this.calculateSimilarity(currentSituation, c.situation);
+ if (similarity > maxSimilarity) {
+ maxSimilarity = similarity;
+ bestMatch = c;
+ }
+ });
+ return maxSimilarity > 0.7 ? bestMatch : null;
+ }
+
+ calculateSimilarity(s1, s2) {
+ let score = 0, total = 0;
+ for (let key in s1) {
+ if (s2[key] !== undefined) {
+ score += 1 - Math.abs(s1[key] - s2[key]);
+ total += 1;
+ }
+ }
+ return total > 0 ? score / total : 0;
+ }
+
+ logCase(c) {
+ const container = document.getElementById('cbr-log-content');
+ if (container) {
+ const div = document.createElement('div');
+ div.className = 'cbr-entry';
+ div.innerHTML = `
+ SIMILAR CASE FOUND (${(this.calculateSimilarity(symbolicEngine.facts, c.situation) * 100).toFixed(0)}%)
+ SUGGESTED: ${c.action}
+ PREVIOUS OUTCOME: ${c.outcome}
+ `;
+ container.prepend(div);
+ if (container.children.length > 3) container.lastElementChild.remove();
+ }
+ }
+}
+
+class NeuroSymbolicBridge {
+ constructor(symbolicEngine, blackboard) {
+ this.engine = symbolicEngine;
+ this.blackboard = blackboard;
+ this.perceptionLog = [];
+ }
+
+ perceive(rawState) {
+ Object.entries(rawState).forEach(([key, value]) => this.engine.addFact(key, value));
+ const concepts = [];
+ if (rawState.stability < 0.4 && rawState.energy > 60) concepts.push('UNSTABLE_OSCILLATION');
+ if (rawState.energy < 30 && rawState.activePortals > 2) concepts.push('CRITICAL_DRAIN_PATTERN');
+ concepts.forEach(concept => {
+ this.engine.addFact(concept, true);
+ this.logPerception(concept);
+ });
+ return concepts;
+ }
+
+ logPerception(concept) {
+ const container = document.getElementById('neuro-bridge-log-content');
+ if (container) {
+ const div = document.createElement('div');
+ div.className = 'neuro-bridge-entry';
+ div.innerHTML = `🧠 ${concept}`;
+ container.prepend(div);
+ if (container.children.length > 5) container.lastElementChild.remove();
+ }
+ }
+}
+
+class MetaReasoningLayer {
+ constructor(planner, blackboard) {
+ this.planner = planner;
+ this.blackboard = blackboard;
+ this.reasoningCache = new Map();
+ this.performanceMetrics = { totalReasoningTime: 0, calls: 0 };
+ }
+
+ getCachedPlan(stateKey) {
+ const cached = this.reasoningCache.get(stateKey);
+ if (cached && (Date.now() - cached.timestamp < 10000)) return cached.plan;
+ return null;
+ }
+
+ cachePlan(stateKey, plan) {
+ this.reasoningCache.set(stateKey, { plan, timestamp: Date.now() });
+ }
+
+ reflect() {
+ const avgTime = this.performanceMetrics.totalReasoningTime / (this.performanceMetrics.calls || 1);
+ const container = document.getElementById('meta-log-content');
+ if (container) {
+ container.innerHTML = `
+ CACHE SIZE: ${this.reasoningCache.size}
+ AVG LATENCY: ${avgTime.toFixed(2)}ms
+ STATUS: ${avgTime > 50 ? 'OPTIMIZING' : 'NOMINAL'}
+ `;
+ }
+ }
+
+ track(startTime) {
+ const duration = performance.now() - startTime;
+ this.performanceMetrics.totalReasoningTime += duration;
+ this.performanceMetrics.calls++;
+ }
+}
+
+// ═══ ADAPTIVE CALIBRATOR (LOCAL EFFICIENCY) ═══
+class AdaptiveCalibrator {
+ constructor(modelId, initialParams) {
+ this.model = modelId;
+ this.weights = {
+ 'input_tokens': 0.0,
+ 'complexity_score': 0.0,
+ 'task_type_indicator': 0.0,
+ 'bias': initialParams.base_rate || 0.0
+ };
+ this.learningRate = 0.01;
+ this.history = [];
+ }
+
+ predict(features) {
+ let prediction = this.weights['bias'];
+ for (let feature in features) {
+ if (this.weights[feature] !== undefined) {
+ prediction += this.weights[feature] * features[feature];
+ }
+ }
+ return Math.max(0, prediction);
+ }
+
+ update(features, actualCost) {
+ const predicted = this.predict(features);
+ const error = actualCost - predicted;
+ for (let feature in features) {
+ if (this.weights[feature] !== undefined) {
+ this.weights[feature] += this.learningRate * error * features[feature];
+ }
+ }
+ this.history.push({ predicted, actual: actualCost, timestamp: Date.now() });
+
+ const container = document.getElementById('calibrator-log-content');
+ if (container) {
+ const div = document.createElement('div');
+ div.className = 'calibrator-entry';
+ div.innerHTML = `CALIBRATED: ${predicted.toFixed(4)} ERR: ${error.toFixed(4)}`;
+ container.prepend(div);
+ if (container.children.length > 5) container.lastElementChild.remove();
+ }
+ }
+}
+
+
+// ═══ NOSTR AGENT REGISTRATION ═══
+class NostrAgent {
+ constructor(pubkey) {
+ this.pubkey = pubkey;
+ this.relays = ['wss://relay.damus.io', 'wss://nos.lol'];
+ }
+
+ async announce(metadata) {
+ console.log(`[NOSTR] Announcing agent ${this.pubkey}...`);
+ const event = {
+ kind: 0,
+ pubkey: this.pubkey,
+ created_at: Math.floor(Date.now() / 1000),
+ tags: [],
+ content: JSON.stringify(metadata),
+ id: 'mock_id',
+ sig: 'mock_sig'
+ };
+
+ this.relays.forEach(url => {
+ console.log(`[NOSTR] Publishing to ${url}: `, event);
+ });
+
+ const container = document.getElementById('nostr-log-content');
+ if (container) {
+ const div = document.createElement('div');
+ div.className = 'nostr-entry';
+ div.innerHTML = `[${this.pubkey.substring(0,8)}...] ANNOUNCED`;
+ container.prepend(div);
+ }
+ }
+}
+
+// ═══ L402 CLIENT LOGIC ═══
+class L402Client {
+ async fetchWithL402(url) {
+ console.log(`[L402] Fetching ${url}...`);
+ const response = await fetch(url);
+
+ if (response.status === 402) {
+ const authHeader = response.headers.get('WWW-Authenticate');
+ console.log(`[L402] Challenge received: ${authHeader}`);
+
+ const container = document.getElementById('l402-log-content');
+ if (container) {
+ const div = document.createElement('div');
+ div.className = 'l402-entry';
+ div.innerHTML = `CHALLENGE Payment Required`;
+ container.prepend(div);
+ }
+ return { status: 402, challenge: authHeader };
+ }
+
+ return response.json();
+ }
+}
+
+let nostrAgent, l402Client;
+
+
+// ═══ PARALLEL SYMBOLIC EXECUTION (PSE) ═══
+class PSELayer {
+ constructor() {
+ this.worker = new Worker('gofai_worker.js');
+ this.worker.onmessage = (e) => this.handleWorkerMessage(e);
+ }
+
+ handleWorkerMessage(e) {
+ const { type, results, plan } = e.data;
+ if (type === 'REASON_RESULT') {
+ results.forEach(res => symbolicEngine.logReasoning(res.rule, res.outcome));
+ } else if (type === 'PLAN_RESULT') {
+ symbolicPlanner.logPlan(plan);
+ }
+ }
+
+ offloadReasoning(facts, rules) {
+ this.worker.postMessage({ type: 'REASON', data: { facts, rules } });
+ }
+
+ offloadPlanning(initialState, goalState, actions) {
+ this.worker.postMessage({ type: 'PLAN', data: { initialState, goalState, actions } });
+ }
+}
+
+let pseLayer;
+
+let resonanceViz, metaLayer, neuroBridge, cbr, symbolicPlanner, knowledgeGraph, blackboard, symbolicEngine, calibrator;
+let agentFSMs = {};
+
+function setupGOFAI() {
+ knowledgeGraph = new KnowledgeGraph();
+ blackboard = new Blackboard();
+ symbolicEngine = new SymbolicEngine();
+ symbolicPlanner = new SymbolicPlanner();
+ cbr = new CaseBasedReasoner();
+ neuroBridge = new NeuroSymbolicBridge(symbolicEngine, blackboard);
+ metaLayer = new MetaReasoningLayer(symbolicPlanner, blackboard);
+ nostrAgent = new NostrAgent("npub1...");
+ l402Client = new L402Client();
+ nostrAgent.announce({ name: "Timmy Nexus Agent", capabilities: ["GOFAI", "L402"] });
+ pseLayer = new PSELayer();
+ calibrator = new AdaptiveCalibrator('nexus-v1', { base_rate: 0.05 });\n MemoryOptimizer.blackboard = blackboard;
+
+ // Setup initial facts
+ symbolicEngine.addFact('energy', 100);
+ symbolicEngine.addFact('stability', 1.0);
+
+ // Setup FSM
+ agentFSMs['timmy'] = new AgentFSM('timmy', 'IDLE');
+ agentFSMs['timmy'].addTransition('IDLE', 'ANALYZING', (facts) => facts.get('activePortals') > 0);
+
+ symbolicEngine.addRule((facts) => facts.get('UNSTABLE_OSCILLATION'), () => 'STABILIZE MATRIX', 'Unstable oscillation demands stabilization', ['UNSTABLE_OSCILLATION']);
+ symbolicEngine.addRule((facts) => facts.get('CRITICAL_DRAIN_PATTERN'), () => 'SHED PORTAL LOAD', 'Critical drain demands portal shedding', ['CRITICAL_DRAIN_PATTERN']);
+
+ // Setup Planner
+ symbolicPlanner.addAction('Stabilize Matrix', { energy: 50 }, { stability: 1.0 });
+ symbolicPlanner.addAction('Shed Portal Load', { activePortals: 1 }, { activePortals: 0, stability: 0.8 });
+}
+
+function deriveGOFAIState(elapsed) {
+ const activeBars = powerMeterBars.reduce((n, _, i) => n + ((((Math.sin(elapsed * 2 + i * 0.5) * 0.5) + 0.5) > (i / Math.max(powerMeterBars.length, 1))) ? 1 : 0), 0);
+ const energy = Math.round((activeBars / Math.max(powerMeterBars.length, 1)) * 100);
+ const stability = Math.max(0.1, Math.min(1, (wsConnected ? 0.55 : 0.2) + (agents.length * 0.05) - (portals.length * 0.03) - (activePortal ? 0.1 : 0) - (portalOverlayActive ? 0.05 : 0)));
+ return { stability, energy, activePortals: activePortal ? 1 : 0 };
+}
+
+function deriveGOFAIGoal(facts) {
+ if (facts.get('CRITICAL_DRAIN_PATTERN')) return { activePortals: 0, stability: 0.8 };
+ if (facts.get('UNSTABLE_OSCILLATION')) return { stability: 1.0 };
+ return { stability: Math.max(0.7, facts.get('stability') || 0.7) };
+}
+
+function updateGOFAI(delta, elapsed) {
+ const startTime = performance.now();
+
+ neuroBridge.perceive(deriveGOFAIState(elapsed));
+ agentFSMs['timmy']?.update(symbolicEngine.facts);
+
+ // Run reasoning
+ if (Math.floor(elapsed * 2) > Math.floor((elapsed - delta) * 2)) {
+ symbolicEngine.reason();
+ pseLayer.offloadReasoning(Array.from(symbolicEngine.facts.entries()), symbolicEngine.rules.map((r) => ({ description: r.description, triggerFacts: r.triggerFacts, workerOutcome: r.action(symbolicEngine.facts), confidence: 0.9 })));
+ pseLayer.offloadPlanning(Object.fromEntries(symbolicEngine.facts), deriveGOFAIGoal(symbolicEngine.facts), symbolicPlanner.actions);
+ document.getElementById("pse-task-count").innerText = parseInt(document.getElementById("pse-task-count").innerText) + 1;
+ metaLayer.reflect();
+
+ // Simulate calibration update
+ calibrator.update({ input_tokens: 100, complexity_score: 0.5 }, 0.06);
+ if (Math.random() > 0.95) l402Client.fetchWithL402(L402_URL);
+ }
+
+ metaLayer.track(startTime);
+}
+
+async function init() {
+ clock = new THREE.Clock();
+ playerPos = new THREE.Vector3(0, 2, 12);
+ playerRot = new THREE.Euler(0, 0, 0, 'YXZ');
+
+ const canvas = document.getElementById('nexus-canvas');
+ renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
+ renderer.setSize(window.innerWidth, window.innerHeight);
+ renderer.toneMapping = THREE.ACESFilmicToneMapping;
+ renderer.toneMappingExposure = 1.2;
+ renderer.shadowMap.enabled = true;
+ renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+
+ performanceTier = detectPerformanceTier();
+ updateLoad(10);
+
+ scene = new THREE.Scene();
+ scene.fog = new THREE.FogExp2(0x050510, 0.012);
+
+ setupGOFAI();\n resonanceViz = new ResonanceVisualizer(scene);
+ camera = new THREE.PerspectiveCamera(65, window.innerWidth / window.innerHeight, 0.1, 1000);
+ camera.position.copy(playerPos);
+
+ // Initialize avatar and LOD systems
+ if (window.AvatarCustomization) window.AvatarCustomization.init(scene, camera);
+ if (window.LODSystem) window.LODSystem.init(scene, camera);
+
+ updateLoad(20);
+
+ createSkybox();
+ updateLoad(30);
+ createLighting();
+ updateLoad(40);
+ createFloor();
+ updateLoad(50);
+ createBatcaveTerminal();
+ updateLoad(60);
+
+ // Load Portals from Registry
+ try {
+ const response = await fetch('./portals.json');
+ const portalData = await response.json();
+ createPortals(portalData);
+ } catch (e) {
+ console.error('Failed to load portals.json:', e);
+ addChatMessage('error', 'Portal registry offline. Check logs.');
+ }
+
+ // Load Vision Points
+ try {
+ const response = await fetch('./vision.json');
+ const visionData = await response.json();
+ createVisionPoints(visionData);
+ } catch (e) {
+ console.error('Failed to load vision.json:', e);
+ }
+
+ updateLoad(80);
+ createParticles();
+ createDustParticles();
+ updateLoad(85);
+ if (performanceTier !== "low") createAmbientStructures();
+ createAgentPresences();
+ if (performanceTier !== "low") createThoughtStream();
+ createHarnessPulse();
+ createSessionPowerMeter();
+ createWorkshopTerminal();
+ if (performanceTier !== "low") createAshStorm();
+ SpatialMemory.init(scene);
+ MemoryBirth.init(scene);
+ MemoryBirth.wrapSpatialMemory(SpatialMemory);
+ SpatialMemory.setCamera(camera);
+ SpatialAudio.init(camera, scene);
+ SpatialAudio.bindSpatialMemory(SpatialMemory);
+ MemoryInspect.init({ onNavigate: _navigateToMemory });
+ MemoryPulse.init(SpatialMemory);
+ ReasoningTrace.init();
+ updateLoad(90);
+
+ loadSession();
+ connectHermes();
+ // Mnemosyne: Periodic GOFAI Optimization
+ setInterval(() => {
+ console.info('[Mnemosyne] Running periodic optimization...');
+ MemoryOptimizer.optimize(SpatialMemory);
+ }, 1000 * 60 * 10); // Every 10 minutes
+
+ fetchGiteaData();
+ setInterval(fetchGiteaData, 30000); // Refresh every 30s
+
+ // 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);
+
+ setupControls();
+ window.addEventListener('resize', onResize);
+ debugOverlay = document.getElementById('debug-overlay');
+
+ updateLoad(100);
+
+ setTimeout(() => {
+ document.getElementById('loading-screen').classList.add('fade-out');
+ const enterPrompt = document.getElementById('enter-prompt');
+ enterPrompt.style.display = 'flex';
+
+ enterPrompt.addEventListener('click', () => {
+ enterPrompt.classList.add('fade-out');
+ document.body.classList.add('visitor-mode');
+ document.getElementById('hud').style.display = 'block';
+ const erpPanel = document.getElementById('evennia-room-panel');
+ if (erpPanel) erpPanel.style.display = 'block';
+ setTimeout(() => { enterPrompt.remove(); }, 600);
+ }, { once: true });
+
+ setTimeout(() => { document.getElementById('loading-screen').remove(); }, 900);
+ }, 600);
+
+ requestAnimationFrame(gameLoop);
+}
+
+function updateLoad(pct) {
+ loadProgress = pct;
+ const fill = document.getElementById('load-progress');
+ if (fill) fill.style.width = pct + '%';
+}
+
+// ═══ PERFORMANCE BUDGET ═══
+function detectPerformanceTier() {
+ const isMobile = /Mobi|Android|iPhone|iPad/i.test(navigator.userAgent) || window.innerWidth < 768;
+ const cores = navigator.hardwareConcurrency || 4;
+
+ if (isMobile) {
+ renderer.setPixelRatio(1);
+ renderer.shadowMap.enabled = false;
+ return 'low';
+ } else if (cores < 8) {
+ renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));
+ renderer.shadowMap.type = THREE.BasicShadowMap;
+ return 'medium';
+ } else {
+ renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+ return 'high';
+ }
+}
+
+function particleCount(base) {
+ if (performanceTier === 'low') return Math.floor(base * 0.25);
+ if (performanceTier === 'medium') return Math.floor(base * 0.6);
+ return base;
+}
+
+// ═══ SKYBOX ═══
+function createSkybox() {
+ const skyGeo = new THREE.SphereGeometry(400, 64, 64);
+ const skyMat = new THREE.ShaderMaterial({
+ uniforms: {
+ uTime: { value: 0 },
+ uColor1: { value: new THREE.Color(0x0a0520) },
+ uColor2: { value: new THREE.Color(0x1a0a3e) },
+ uColor3: { value: new THREE.Color(0x0a1a3e) },
+ uStarDensity: { value: 0.97 },
+ },
+ vertexShader: `
+ varying vec3 vPos;
+ void main() {
+ vPos = position;
+ gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+ }
+ `,
+ fragmentShader: `
+ uniform float uTime;
+ uniform vec3 uColor1;
+ uniform vec3 uColor2;
+ uniform vec3 uColor3;
+ uniform float uStarDensity;
+ varying vec3 vPos;
+
+ float hash(vec3 p) {
+ p = fract(p * vec3(443.897, 441.423, 437.195));
+ p += dot(p, p.yzx + 19.19);
+ return fract((p.x + p.y) * p.z);
+ }
+
+ float noise(vec3 p) {
+ vec3 i = floor(p);
+ vec3 f = fract(p);
+ f = f * f * (3.0 - 2.0 * f);
+ return mix(
+ mix(mix(hash(i), hash(i + vec3(1,0,0)), f.x),
+ mix(hash(i + vec3(0,1,0)), hash(i + vec3(1,1,0)), f.x), f.y),
+ mix(mix(hash(i + vec3(0,0,1)), hash(i + vec3(1,0,1)), f.x),
+ mix(hash(i + vec3(0,1,1)), hash(i + vec3(1,1,1)), f.x), f.y),
+ f.z
+ );
+ }
+
+ float fbm(vec3 p) {
+ float v = 0.0;
+ float a = 0.5;
+ for (int i = 0; i < 5; i++) {
+ v += a * noise(p);
+ p *= 2.0;
+ a *= 0.5;
+ }
+ return v;
+ }
+
+ void main() {
+ vec3 dir = normalize(vPos);
+ float n1 = fbm(dir * 3.0 + uTime * 0.02);
+ float n2 = fbm(dir * 5.0 - uTime * 0.015 + 100.0);
+ float n3 = fbm(dir * 2.0 + uTime * 0.01 + 200.0);
+
+ vec3 col = uColor1;
+ col = mix(col, uColor2, smoothstep(0.3, 0.7, n1));
+ col = mix(col, uColor3, smoothstep(0.4, 0.8, n2) * 0.5);
+
+ float glow = pow(n1 * n2, 2.0) * 1.5;
+ col += vec3(0.15, 0.05, 0.25) * glow;
+ col += vec3(0.05, 0.15, 0.25) * pow(n3, 3.0);
+
+ float starField = hash(dir * 800.0);
+ float stars = step(uStarDensity, starField) * (0.5 + 0.5 * hash(dir * 1600.0));
+ float twinkle = 0.7 + 0.3 * sin(uTime * 2.0 + hash(dir * 400.0) * 6.28);
+ col += vec3(stars * twinkle);
+
+ float bigStar = step(0.998, starField);
+ col += vec3(0.8, 0.9, 1.0) * bigStar * twinkle;
+
+ gl_FragColor = vec4(col, 1.0);
+ }
+ `,
+ side: THREE.BackSide,
+ });
+ const sky = new THREE.Mesh(skyGeo, skyMat);
+ sky.name = 'skybox';
+ scene.add(sky);
+}
+
+// ═══ LIGHTING ═══
+function createLighting() {
+ const ambient = new THREE.AmbientLight(0x1a1a3a, 0.4);
+ scene.add(ambient);
+
+ const dirLight = new THREE.DirectionalLight(0x4466aa, 0.6);
+ dirLight.position.set(10, 20, 10);
+ dirLight.castShadow = renderer.shadowMap.enabled;
+ const shadowRes = performanceTier === 'high' ? 2048 : performanceTier === 'medium' ? 1024 : 512;
+ dirLight.shadow.mapSize.set(shadowRes, shadowRes);
+ scene.add(dirLight);
+
+ const tealLight = new THREE.PointLight(NEXUS.colors.primary, 2, 30, 1.5);
+ tealLight.position.set(0, 1, -5);
+ scene.add(tealLight);
+
+ const purpleLight = new THREE.PointLight(NEXUS.colors.secondary, 1.5, 25, 1.5);
+ purpleLight.position.set(-8, 3, -8);
+ scene.add(purpleLight);
+}
+
+// ═══ FLOOR ═══
+function createFloor() {
+ const platGeo = new THREE.CylinderGeometry(25, 25, 0.3, 6);
+ const platMat = new THREE.MeshStandardMaterial({
+ color: 0x0a0f1a,
+ roughness: 0.8,
+ metalness: 0.3,
+ });
+ const platform = new THREE.Mesh(platGeo, platMat);
+ platform.position.y = -0.15;
+ platform.receiveShadow = true;
+ scene.add(platform);
+
+ const gridHelper = new THREE.GridHelper(50, 50, NEXUS.colors.gridLine, NEXUS.colors.gridLine);
+ gridHelper.material.opacity = 0.15;
+ gridHelper.material.transparent = true;
+ gridHelper.position.y = 0.02;
+ scene.add(gridHelper);
+
+ const ringGeo = new THREE.RingGeometry(24.5, 25.2, 6);
+ const ringMat = new THREE.MeshBasicMaterial({
+ color: NEXUS.colors.primary,
+ transparent: true,
+ opacity: 0.4,
+ side: THREE.DoubleSide,
+ });
+ const ring = new THREE.Mesh(ringGeo, ringMat);
+ ring.rotation.x = Math.PI / 2;
+ ring.position.y = 0.05;
+ scene.add(ring);
+}
+
+// ═══ BATCAVE TERMINAL ═══
+function createBatcaveTerminal() {
+ const terminalGroup = new THREE.Group();
+ terminalGroup.position.set(0, 0, -8);
+
+ const panelData = [
+ { title: 'NEXUS COMMAND', color: NEXUS.colors.primary, rot: -0.4, x: -6, y: 3, lines: ['> STATUS: NOMINAL', '> UPTIME: 142.4h', '> HARNESS: STABLE', '> MODE: SOVEREIGN'] },
+ { title: 'DEV QUEUE', color: NEXUS.colors.gold, rot: -0.2, x: -3, y: 3, lines: ['> ISSUE #4: CORE', '> ISSUE #5: PORTAL', '> ISSUE #6: TERMINAL', '> ISSUE #7: TIMMY'] },
+ { title: 'METRICS', color: NEXUS.colors.secondary, rot: 0, x: 0, y: 3, lines: ['> CPU: 12% [||....]', '> MEM: 4.2GB', '> COMMITS: 842', '> ACTIVE LOOPS: 5'] },
+ { title: 'SOVEREIGNTY', color: NEXUS.colors.gold, rot: 0.2, x: 3, y: 3, lines: ['REPLIT: GRADE: A', 'PERPLEXITY: GRADE: A-', 'HERMES: GRADE: B+', 'KIMI: GRADE: B', 'CLAUDE: GRADE: B+'] },
+ { title: 'AGENT STATUS', color: NEXUS.colors.primary, rot: 0.4, x: 6, y: 3, lines: ['> TIMMY: ● RUNNING', '> KIMI: ○ STANDBY', '> CLAUDE: ● ACTIVE', '> PERPLEXITY: ○'] },
+ ];
+
+ panelData.forEach(data => {
+ const terminal = createTerminalPanel(terminalGroup, data.x, data.y, data.rot, data.title, data.color, data.lines);
+ batcaveTerminals.push(terminal);
+ });
+
+ scene.add(terminalGroup);
+}
+
+// ═══ WORKSHOP TERMINAL ═══
+function createWorkshopTerminal() {
+ const w = 6, h = 4;
+ const group = new THREE.Group();
+ group.position.set(-14, 3, 0);
+ group.rotation.y = Math.PI / 4;
+
+ workshopPanelCanvas = document.createElement('canvas');
+ workshopPanelCanvas.width = 1024;
+ workshopPanelCanvas.height = 512;
+ workshopPanelCtx = workshopPanelCanvas.getContext('2d');
+
+ workshopPanelTexture = new THREE.CanvasTexture(workshopPanelCanvas);
+ workshopPanelTexture.minFilter = THREE.LinearFilter;
+
+ const panelGeo = new THREE.PlaneGeometry(w, h);
+ const panelMat = new THREE.MeshBasicMaterial({
+ map: workshopPanelTexture,
+ transparent: true,
+ opacity: 0.9,
+ side: THREE.DoubleSide
+ });
+ const panel = new THREE.Mesh(panelGeo, panelMat);
+ group.add(panel);
+
+ const scanGeo = new THREE.PlaneGeometry(w + 0.1, h + 0.1);
+ workshopScanMat = new THREE.ShaderMaterial({
+ transparent: true,
+ uniforms: { uTime: { value: 0 } },
+ vertexShader: `varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`,
+ fragmentShader: `
+ uniform float uTime;
+ varying vec2 vUv;
+ void main() {
+ float scan = sin(vUv.y * 200.0 + uTime * 10.0) * 0.05;
+ float noise = fract(sin(dot(vUv, vec2(12.9898, 78.233))) * 43758.5453) * 0.05;
+ gl_FragColor = vec4(0.0, 0.1, 0.2, scan + noise);
+ }
+ `
+ });
+ const scan = new THREE.Mesh(scanGeo, workshopScanMat);
+ scan.position.z = 0.01;
+ group.add(scan);
+
+ scene.add(group);
+ refreshWorkshopPanel();
+}
+
+function refreshWorkshopPanel() {
+ if (!workshopPanelCtx) return;
+ const ctx = workshopPanelCtx;
+ const w = 1024, h = 512;
+
+ ctx.clearRect(0, 0, w, h);
+ ctx.fillStyle = 'rgba(10, 15, 40, 0.8)';
+ ctx.fillRect(0, 0, w, h);
+
+ ctx.fillStyle = '#4af0c0';
+ ctx.font = 'bold 40px "Orbitron", sans-serif';
+ ctx.fillText('WORKSHOP TERMINAL v1.0', 40, 60);
+ ctx.fillRect(40, 80, 944, 4);
+
+ ctx.font = '24px "JetBrains Mono", monospace';
+ ctx.fillStyle = wsConnected ? '#4af0c0' : '#ff4466';
+ ctx.fillText(`HERMES STATUS: ${wsConnected ? 'ONLINE' : 'OFFLINE'}`, 40, 120);
+
+ ctx.fillStyle = '#7b5cff';
+ const contextName = activePortal ? activePortal.name.toUpperCase() : 'NEXUS CORE';
+ ctx.fillText(`CONTEXT: ${contextName}`, 40, 160);
+
+ ctx.fillStyle = '#a0b8d0';
+ ctx.font = 'bold 20px "Orbitron", sans-serif';
+ ctx.fillText('TOOL OUTPUT STREAM', 40, 220);
+ ctx.fillRect(40, 230, 400, 2);
+
+ ctx.font = '16px "JetBrains Mono", monospace';
+ recentToolOutputs.slice(-10).forEach((out, i) => {
+ ctx.fillStyle = out.type === 'call' ? '#ffd700' : '#4af0c0';
+ const text = `[${out.agent}] ${out.content.substring(0, 80)}${out.content.length > 80 ? '...' : ''}`;
+ ctx.fillText(text, 40, 260 + i * 24);
+ });
+
+ workshopPanelTexture.needsUpdate = true;
+}
+
+function createTerminalPanel(parent, x, y, rot, title, color, lines) {
+ const w = 2.8, h = 3.5;
+ const group = new THREE.Group();
+ group.position.set(x, y, 0);
+ group.rotation.y = rot;
+
+ const bgGeo = new THREE.PlaneGeometry(w, h);
+ const bgMat = new THREE.MeshPhysicalMaterial({
+ color: NEXUS.colors.panelBg,
+ transparent: true,
+ opacity: 0.6,
+ roughness: 0.1,
+ metalness: 0.5,
+ side: THREE.DoubleSide,
+ });
+ const bg = new THREE.Mesh(bgGeo, bgMat);
+ group.add(bg);
+
+ const borderMat = new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 0.3, side: THREE.DoubleSide });
+ const border = new THREE.Mesh(new THREE.PlaneGeometry(w + 0.05, h + 0.05), borderMat);
+ border.position.z = -0.01;
+ group.add(border);
+
+ const textCanvas = document.createElement('canvas');
+ textCanvas.width = 512;
+ textCanvas.height = 640;
+ const ctx = textCanvas.getContext('2d');
+
+ const textTexture = new THREE.CanvasTexture(textCanvas);
+ textTexture.minFilter = THREE.LinearFilter;
+
+ function updatePanelText(newLines) {
+ ctx.clearRect(0, 0, 512, 640);
+ ctx.fillStyle = '#' + new THREE.Color(color).getHexString();
+ ctx.font = 'bold 32px "Orbitron", sans-serif';
+ ctx.fillText(title, 20, 45);
+ ctx.fillRect(20, 55, 472, 2);
+ ctx.font = '20px "JetBrains Mono", monospace';
+ ctx.fillStyle = '#a0b8d0';
+ const displayLines = newLines || lines;
+ displayLines.forEach((line, i) => {
+ let fillColor = '#a0b8d0';
+ if (line.includes('● RUNNING') || line.includes('● ACTIVE') || line.includes('ONLINE')) fillColor = '#4af0c0';
+ else if (line.includes('○ STANDBY') || line.includes('OFFLINE')) fillColor = '#5a6a8a';
+ else if (line.includes('NOMINAL')) fillColor = '#4af0c0';
+ ctx.fillStyle = fillColor;
+ ctx.fillText(line, 20, 100 + i * 40);
+ });
+ textTexture.needsUpdate = true;
+ }
+
+ updatePanelText();
+
+ const textMat = new THREE.MeshBasicMaterial({
+ map: textTexture,
+ transparent: true,
+ side: THREE.DoubleSide,
+ depthWrite: false,
+ });
+ const textMesh = new THREE.Mesh(new THREE.PlaneGeometry(w * 0.95, h * 0.95), textMat);
+ textMesh.position.z = 0.01;
+ group.add(textMesh);
+
+ const scanGeo = new THREE.PlaneGeometry(w, h);
+ const scanMat = new THREE.ShaderMaterial({
+ transparent: true,
+ depthWrite: false,
+ uniforms: { uTime: { value: 0 }, uColor: { value: new THREE.Color(color) } },
+ vertexShader: `
+ varying vec2 vUv;
+ void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }
+ `,
+ fragmentShader: `
+ uniform float uTime;
+ uniform vec3 uColor;
+ varying vec2 vUv;
+ void main() {
+ float scanline = sin(vUv.y * 200.0 + uTime * 2.0) * 0.5 + 0.5;
+ scanline = pow(scanline, 8.0);
+ float sweep = smoothstep(0.0, 0.02, abs(fract(vUv.y - uTime * 0.1) - 0.5));
+ sweep = 1.0 - (1.0 - sweep) * 0.3;
+ float alpha = scanline * 0.04 + (1.0 - sweep) * 0.08;
+ gl_FragColor = vec4(uColor, alpha);
+ }
+ `,
+ side: THREE.DoubleSide,
+ });
+ const scanMesh = new THREE.Mesh(scanGeo, scanMat);
+ scanMesh.position.z = 0.02;
+ group.add(scanMesh);
+
+ parent.add(group);
+ return { group, scanMat, borderMat, updatePanelText, title };
+}
+
+// ═══ GITEA DATA INTEGRATION ═══
+async function fetchGiteaData() {
+ try {
+ const [issuesRes, stateRes] = await Promise.all([
+ fetch('https://forge.alexanderwhitestone.com/api/v1/repos/Timmy_Foundation/the-nexus/issues?state=all&limit=20'),
+ fetch('https://forge.alexanderwhitestone.com/api/v1/repos/Timmy_Foundation/the-nexus/contents/vision.json')
+ ]);
+
+ if (issuesRes.ok) {
+ const issues = await issuesRes.json();
+ updateDevQueue(issues);
+ updateAgentStatus(issues);
+ }
+
+ if (stateRes.ok) {
+ const content = await stateRes.json();
+ const worldState = JSON.parse(atob(content.content));
+ updateNexusCommand(worldState);
+ updateSovereignHealth();
+ }
+ } catch (e) {
+ console.error('Failed to fetch Gitea data:', e);
+ }
+}
+
+function updateAgentStatus(issues) {
+ const terminal = batcaveTerminals.find(t => t.title === 'AGENT STATUS');
+ if (!terminal) return;
+
+ // Check for Morrowind issues
+ const morrowindIssues = issues.filter(i => i.title.toLowerCase().includes('morrowind') && i.state === 'open');
+ const perplexityStatus = morrowindIssues.length > 0 ? '● MORROWIND' : '○ STANDBY';
+
+ const lines = [
+ '> TIMMY: ● RUNNING',
+ '> KIMI: ○ STANDBY',
+ '> CLAUDE: ● ACTIVE',
+ `> PERPLEXITY: ${perplexityStatus}`
+ ];
+ terminal.updatePanelText(lines);
+}
+
+function updateDevQueue(issues) {
+ const terminal = batcaveTerminals.find(t => t.title === 'DEV QUEUE');
+ if (!terminal) return;
+
+ const lines = issues.slice(0, 4).map(issue => `> #${issue.number}: ${issue.title.substring(0, 15)}...`);
+ while (lines.length < 4) lines.push('> [EMPTY SLOT]');
+ terminal.updatePanelText(lines);
+}
+
+
+async function updateSovereignHealth() {
+ const container = document.getElementById('sovereign-health-content');
+ if (!container) return;
+
+ let metrics = { sovereignty_score: 100, local_sessions: 0, total_sessions: 0 };
+ let daemonReachable = false;
+ try {
+ const res = await fetch('http://localhost:8082/metrics');
+ if (res.ok) {
+ metrics = await res.json();
+ daemonReachable = true;
+ }
+ } catch (e) {
+ console.log('Local health daemon not reachable, using static baseline.');
+ }
+
+ const services = [
+ { name: 'LOCAL DAEMON', status: daemonReachable ? 'ONLINE' : 'OFFLINE' },
+ { name: 'FORGE / GITEA', url: 'https://forge.alexanderwhitestone.com', status: 'ONLINE' },
+ { name: 'NEXUS CORE', url: 'https://forge.alexanderwhitestone.com/Timmy_Foundation/the-nexus', status: 'ONLINE' },
+ { name: 'HERMES WS', url: 'ws://143.198.27.163:8765', status: wsConnected ? 'ONLINE' : 'OFFLINE' },
+ { name: 'SOVEREIGNTY', url: 'http://localhost:8082/metrics', status: metrics.sovereignty_score + '%' }
+ ];
+
+ container.innerHTML = '';
+
+ // Add Sovereignty Bar
+ const barDiv = document.createElement('div');
+ barDiv.className = 'meta-stat';
+ barDiv.style.flexDirection = 'column';
+ barDiv.style.alignItems = 'flex-start';
+ barDiv.innerHTML = `
+
+ SOVEREIGNTY SCORE
+ ${metrics.sovereignty_score}%
+
+
+ `;
+ container.appendChild(barDiv);
+
+ // Session metrics (if daemon provides them)
+ if (daemonReachable && (metrics.local_sessions || metrics.total_sessions)) {
+ const sessDiv = document.createElement('div');
+ sessDiv.className = 'meta-stat';
+ sessDiv.innerHTML = `SESSIONS${metrics.local_sessions || 0} local / ${metrics.total_sessions || 0} total`;
+ container.appendChild(sessDiv);
+ }
+
+ services.forEach(s => {
+ const div = document.createElement('div');
+ div.className = 'meta-stat';
+ div.innerHTML = `${s.name} ${s.status}`;
+ container.appendChild(div);
+ });
+
+ // Last updated timestamp
+ const tsDiv = document.createElement('div');
+ tsDiv.className = 'meta-stat';
+ tsDiv.style.opacity = '0.5';
+ tsDiv.style.fontSize = '0.7em';
+ tsDiv.textContent = `UPDATED ${new Date().toLocaleTimeString()}`;
+ container.appendChild(tsDiv);
+}
+
+function updateNexusCommand(state) {
+ const terminal = batcaveTerminals.find(t => t.title === 'NEXUS COMMAND');
+ if (!terminal) return;
+
+ const lines = [
+ `> STATUS: ${state.tower.status.toUpperCase()}`,
+ `> ENERGY: ${state.tower.energy}%`,
+ `> STABILITY: ${(state.matrix.stability * 100).toFixed(1)}%`,
+ `> AGENTS: ${state.matrix.active_agents.length}`
+ ];
+ terminal.updatePanelText(lines);
+}
+
+// ═══ AGENT PRESENCE SYSTEM ═══
+function createAgentPresences() {
+ const agentData = [
+ { id: 'timmy', name: 'TIMMY', color: NEXUS.colors.primary, pos: { x: -4, z: -4 }, station: { x: -4, z: -4 } },
+ { id: 'kimi', name: 'KIMI', color: NEXUS.colors.secondary, pos: { x: 4, z: -4 }, station: { x: 4, z: -4 } },
+ { id: 'claude', name: 'CLAUDE', color: NEXUS.colors.gold, pos: { x: 0, z: -6 }, station: { x: 0, z: -6 } },
+ { id: 'perplexity', name: 'PERPLEXITY', color: 0x4488ff, pos: { x: -6, z: -2 }, station: { x: -6, z: -2 } },
+ ];
+
+ agentData.forEach(data => {
+ const group = new THREE.Group();
+ group.position.set(data.pos.x, 0, data.pos.z);
+
+ const color = new THREE.Color(data.color);
+
+ // Agent Orb
+ const orbGeo = new THREE.SphereGeometry(0.4, 32, 32);
+ const orbMat = new THREE.MeshPhysicalMaterial({
+ color: color,
+ emissive: color,
+ emissiveIntensity: 2,
+ roughness: 0,
+ metalness: 1,
+ transmission: 0.8,
+ thickness: 0.5,
+ });
+ const orb = new THREE.Mesh(orbGeo, orbMat);
+ orb.position.y = 3;
+ group.add(orb);
+
+ // Halo
+ const haloGeo = new THREE.TorusGeometry(0.6, 0.02, 16, 64);
+ const haloMat = new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 0.4 });
+ const halo = new THREE.Mesh(haloGeo, haloMat);
+ halo.position.y = 3;
+ halo.rotation.x = Math.PI / 2;
+ group.add(halo);
+
+ // Label
+ const canvas = document.createElement('canvas');
+ canvas.width = 256;
+ canvas.height = 64;
+ const ctx = canvas.getContext('2d');
+ ctx.font = 'bold 24px "Orbitron", sans-serif';
+ ctx.fillStyle = '#' + color.getHexString();
+ ctx.textAlign = 'center';
+ ctx.fillText(data.name, 128, 40);
+ const tex = new THREE.CanvasTexture(canvas);
+ const mat = new THREE.MeshBasicMaterial({ map: tex, transparent: true, side: THREE.DoubleSide });
+ const label = new THREE.Mesh(new THREE.PlaneGeometry(2, 0.5), mat);
+ label.position.y = 3.8;
+ group.add(label);
+
+ scene.add(group);
+ agents.push({
+ id: data.id,
+ group,
+ orb,
+ halo,
+ color,
+ station: data.station,
+ targetPos: new THREE.Vector3(data.pos.x, 0, data.pos.z),
+ wanderTimer: 0
+ });
+ });
+}
+
+function createThoughtStream() {
+ const geo = new THREE.CylinderGeometry(8, 8, 12, 32, 1, true);
+ const mat = new THREE.ShaderMaterial({
+ transparent: true,
+ side: THREE.BackSide,
+ depthWrite: false,
+ uniforms: {
+ uTime: { value: 0 },
+ uColor: { value: new THREE.Color(NEXUS.colors.primary) },
+ },
+ vertexShader: `
+ varying vec2 vUv;
+ void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }
+ `,
+ fragmentShader: `
+ uniform float uTime;
+ uniform vec3 uColor;
+ varying vec2 vUv;
+
+ float hash(vec2 p) { return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }
+
+ void main() {
+ float flow = fract(vUv.y - uTime * 0.1);
+ float lines = step(0.98, fract(vUv.x * 20.0 + uTime * 0.05));
+ float dots = step(0.99, hash(vUv * 50.0 + floor(uTime * 10.0) * 0.01));
+
+ float alpha = (lines * 0.1 + dots * 0.5) * smoothstep(0.0, 0.2, vUv.y) * smoothstep(1.0, 0.8, vUv.y);
+ gl_FragColor = vec4(uColor, alpha * 0.3);
+ }
+ `,
+ });
+ thoughtStreamMesh = new THREE.Mesh(geo, mat);
+ thoughtStreamMesh.position.y = 6;
+ scene.add(thoughtStreamMesh);
+}
+
+function createHarnessPulse() {
+ const geo = new THREE.RingGeometry(0.1, 0.2, 64);
+ const mat = new THREE.MeshBasicMaterial({
+ color: NEXUS.colors.primary,
+ transparent: true,
+ opacity: 0,
+ side: THREE.DoubleSide,
+ });
+ harnessPulseMesh = new THREE.Mesh(geo, mat);
+ harnessPulseMesh.rotation.x = -Math.PI / 2;
+ harnessPulseMesh.position.y = 0.1;
+ scene.add(harnessPulseMesh);
+}
+
+function createSessionPowerMeter() {
+ const group = new THREE.Group();
+ group.position.set(0, 0, 3);
+
+ const barCount = 12;
+ const barGeo = new THREE.BoxGeometry(0.2, 0.1, 0.1);
+
+ for (let i = 0; i < barCount; i++) {
+ const mat = new THREE.MeshStandardMaterial({
+ color: NEXUS.colors.primary,
+ emissive: NEXUS.colors.primary,
+ emissiveIntensity: 0.2,
+ transparent: true,
+ opacity: 0.6
+ });
+ const bar = new THREE.Mesh(barGeo, mat);
+ bar.position.y = 0.2 + i * 0.2;
+ group.add(bar);
+ powerMeterBars.push(bar);
+ }
+
+ const labelCanvas = document.createElement('canvas');
+ labelCanvas.width = 256;
+ labelCanvas.height = 64;
+ const ctx = labelCanvas.getContext('2d');
+ ctx.font = 'bold 24px "Orbitron", sans-serif';
+ ctx.fillStyle = '#4af0c0';
+ ctx.textAlign = 'center';
+ ctx.fillText('POWER LEVEL', 128, 40);
+ const tex = new THREE.CanvasTexture(labelCanvas);
+ const labelMat = new THREE.MeshBasicMaterial({ map: tex, transparent: true, side: THREE.DoubleSide });
+ const label = new THREE.Mesh(new THREE.PlaneGeometry(2, 0.5), labelMat);
+ label.position.y = 3;
+ group.add(label);
+
+ scene.add(group);
+}
+
+// ═══ VISION SYSTEM ═══
+function createVisionPoints(data) {
+ data.forEach(config => {
+ const vp = createVisionPoint(config);
+ visionPoints.push(vp);
+ });
+}
+
+function createVisionPoint(config) {
+ const group = new THREE.Group();
+ group.position.set(config.position.x, config.position.y, config.position.z);
+
+ const color = new THREE.Color(config.color);
+
+ // Floating Crystal
+ const crystalGeo = new THREE.OctahedronGeometry(0.6, 0);
+ const crystalMat = new THREE.MeshPhysicalMaterial({
+ color: color,
+ emissive: color,
+ emissiveIntensity: 1,
+ roughness: 0,
+ metalness: 1,
+ transmission: 0.5,
+ thickness: 1,
+ });
+ const crystal = new THREE.Mesh(crystalGeo, crystalMat);
+ crystal.position.y = 2.5;
+ group.add(crystal);
+
+ // Glow Ring
+ const ringGeo = new THREE.TorusGeometry(0.8, 0.02, 16, 64);
+ const ringMat = new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 0.5 });
+ const ring = new THREE.Mesh(ringGeo, ringMat);
+ ring.position.y = 2.5;
+ ring.rotation.x = Math.PI / 2;
+ group.add(ring);
+
+ // Light
+ const light = new THREE.PointLight(color, 1, 10);
+ light.position.set(0, 2.5, 0);
+ group.add(light);
+
+ scene.add(group);
+
+ return { config, group, crystal, ring, light };
+}
+
+// ═══ PORTAL SYSTEM ═══
+function createPortals(data) {
+ data.forEach(config => {
+ const portal = createPortal(config);
+ portals.push(portal);
+ });
+}
+
+function createPortal(config) {
+ const group = new THREE.Group();
+ group.position.set(config.position.x, config.position.y, config.position.z);
+ if (config.rotation) {
+ group.rotation.y = config.rotation.y;
+ }
+
+ const portalColor = new THREE.Color(config.color);
+
+ // Torus Ring
+ const torusGeo = new THREE.TorusGeometry(3, 0.15, 16, 64);
+ const torusMat = new THREE.MeshStandardMaterial({
+ color: portalColor,
+ emissive: portalColor,
+ emissiveIntensity: 1.5,
+ roughness: 0.2,
+ metalness: 0.8,
+ });
+ const ring = new THREE.Mesh(torusGeo, torusMat);
+ ring.position.y = 3.5;
+ ring.name = `portal_ring_${config.id}`;
+ group.add(ring);
+
+ // Swirl Disc
+ const swirlGeo = new THREE.CircleGeometry(2.8, 64);
+ const swirlMat = new THREE.ShaderMaterial({
+ transparent: true,
+ side: THREE.DoubleSide,
+ uniforms: {
+ uTime: { value: 0 },
+ uColor: { value: portalColor },
+ },
+ vertexShader: `
+ varying vec2 vUv;
+ void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }
+ `,
+ fragmentShader: `
+ uniform float uTime;
+ uniform vec3 uColor;
+ varying vec2 vUv;
+ void main() {
+ vec2 c = vUv - 0.5;
+ float r = length(c);
+ float a = atan(c.y, c.x);
+ float swirl = sin(a * 3.0 + r * 10.0 - uTime * 3.0) * 0.5 + 0.5;
+ float swirl2 = sin(a * 5.0 - r * 8.0 + uTime * 2.0) * 0.5 + 0.5;
+ float mask = smoothstep(0.5, 0.1, r);
+ vec3 col = mix(uColor, vec3(1.0, 1.0, 1.0), swirl * 0.3);
+ col = mix(col, vec3(1.0, 1.0, 1.0), swirl2 * 0.2);
+ float alpha = mask * (0.5 + 0.3 * swirl);
+ gl_FragColor = vec4(col, alpha);
+ }
+ `,
+ });
+ const swirl = new THREE.Mesh(swirlGeo, swirlMat);
+ swirl.position.y = 3.5;
+ group.add(swirl);
+
+ // Orbital Particles
+ const pCount = 120;
+ const pGeo = new THREE.BufferGeometry();
+ const pPos = new Float32Array(pCount * 3);
+ const pSizes = new Float32Array(pCount);
+ for (let i = 0; i < pCount; i++) {
+ const angle = Math.random() * Math.PI * 2;
+ const r = 3.2 + Math.random() * 0.5;
+ pPos[i * 3] = Math.cos(angle) * r;
+ pPos[i * 3 + 1] = 3.5 + (Math.random() - 0.5) * 6;
+ pPos[i * 3 + 2] = (Math.random() - 0.5) * 0.5;
+ pSizes[i] = 0.05 + Math.random() * 0.1;
+ }
+ pGeo.setAttribute('position', new THREE.BufferAttribute(pPos, 3));
+ pGeo.setAttribute('size', new THREE.BufferAttribute(pSizes, 1));
+ const pMat = new THREE.PointsMaterial({
+ color: portalColor,
+ size: 0.08,
+ transparent: true,
+ opacity: 0.6,
+ blending: THREE.AdditiveBlending,
+ depthWrite: false,
+ });
+ const pSystem = new THREE.Points(pGeo, pMat);
+ group.add(pSystem);
+
+ // Pulsing Point Light
+ const light = new THREE.PointLight(portalColor, 2, 15, 1.5);
+ light.position.set(0, 3.5, 1);
+ group.add(light);
+
+ // Label
+ const labelCanvas = document.createElement('canvas');
+ labelCanvas.width = 512;
+ labelCanvas.height = 96;
+ const lctx = labelCanvas.getContext('2d');
+ lctx.font = 'bold 32px "Orbitron", sans-serif';
+ lctx.fillStyle = '#' + portalColor.getHexString();
+ lctx.textAlign = 'center';
+ lctx.fillText(`◈ ${config.name.toUpperCase()}`, 256, 36);
+ // Role tag (timmy/reflex/pilot) — defines portal ownership boundary
+ if (config.role) {
+ const roleColors = { timmy: '#4af0c0', reflex: '#ff4466', pilot: '#ffd700' };
+ lctx.font = 'bold 18px "Orbitron", sans-serif';
+ lctx.fillStyle = roleColors[config.role] || '#888888';
+ lctx.fillText(config.role.toUpperCase(), 256, 68);
+ }
+ const labelTex = new THREE.CanvasTexture(labelCanvas);
+ const labelMat = new THREE.MeshBasicMaterial({ map: labelTex, transparent: true, side: THREE.DoubleSide });
+ const labelMesh = new THREE.Mesh(new THREE.PlaneGeometry(4, 0.75), labelMat);
+ labelMesh.position.y = 7.5;
+ group.add(labelMesh);
+
+ // Base Pillars
+ for (let side of [-1, 1]) {
+ const pillarGeo = new THREE.CylinderGeometry(0.2, 0.3, 7, 8);
+ const pillarMat = new THREE.MeshStandardMaterial({
+ color: 0x1a1a2e,
+ roughness: 0.5,
+ metalness: 0.7,
+ emissive: portalColor,
+ emissiveIntensity: 0.1,
+ });
+ const pillar = new THREE.Mesh(pillarGeo, pillarMat);
+ pillar.position.set(side * 3, 3.5, 0);
+ pillar.castShadow = true;
+ group.add(pillar);
+ }
+
+ scene.add(group);
+
+ const portalObj = {
+ config,
+ group,
+ ring,
+ swirl,
+ pSystem,
+ light,
+ customElements: {}
+ };
+
+ // ═══ DISTINCT VISUAL IDENTITIES ═══
+ if (config.id === 'archive') {
+ // Floating Data Cubes
+ const cubes = [];
+ for (let i = 0; i < 6; i++) {
+ const cubeGeo = new THREE.BoxGeometry(0.4, 0.4, 0.4);
+ const cubeMat = new THREE.MeshStandardMaterial({
+ color: portalColor,
+ emissive: portalColor,
+ emissiveIntensity: 1.5,
+ transparent: true,
+ opacity: 0.8
+ });
+ const cube = new THREE.Mesh(cubeGeo, cubeMat);
+ group.add(cube);
+ cubes.push(cube);
+ }
+ portalObj.customElements.cubes = cubes;
+ } else if (config.id === 'chapel') {
+ // Glowing Core + Halo
+ const coreGeo = new THREE.SphereGeometry(1.2, 32, 32);
+ const coreMat = new THREE.MeshPhysicalMaterial({
+ color: 0xffffff,
+ emissive: portalColor,
+ emissiveIntensity: 2,
+ transparent: true,
+ opacity: 0.4,
+ transmission: 0.9,
+ thickness: 2
+ });
+ const core = new THREE.Mesh(coreGeo, coreMat);
+ core.position.y = 3.5;
+ group.add(core);
+ portalObj.customElements.core = core;
+
+ const haloGeo = new THREE.TorusGeometry(3.5, 0.05, 16, 100);
+ const haloMat = new THREE.MeshBasicMaterial({ color: portalColor, transparent: true, opacity: 0.3 });
+ const halo = new THREE.Mesh(haloGeo, haloMat);
+ halo.position.y = 3.5;
+ group.add(halo);
+ portalObj.customElements.halo = halo;
+ } else if (config.id === 'courtyard') {
+ // Double Rotating Rings
+ const outerRingGeo = new THREE.TorusGeometry(4.2, 0.1, 16, 80);
+ const outerRingMat = new THREE.MeshStandardMaterial({
+ color: portalColor,
+ emissive: portalColor,
+ emissiveIntensity: 0.8,
+ transparent: true,
+ opacity: 0.5
+ });
+ const outerRing = new THREE.Mesh(outerRingGeo, outerRingMat);
+ outerRing.position.y = 3.5;
+ group.add(outerRing);
+ portalObj.customElements.outerRing = outerRing;
+ } else if (config.id === 'gate') {
+ // Spiky Monoliths
+ const spikes = [];
+ for (let i = 0; i < 8; i++) {
+ const spikeGeo = new THREE.ConeGeometry(0.2, 1.5, 4);
+ const spikeMat = new THREE.MeshStandardMaterial({ color: 0x111111, emissive: portalColor, emissiveIntensity: 0.5 });
+ const spike = new THREE.Mesh(spikeGeo, spikeMat);
+ const angle = (i / 8) * Math.PI * 2;
+ spike.position.set(Math.cos(angle) * 3.5, 3.5 + Math.sin(angle) * 3.5, 0);
+ spike.rotation.z = angle + Math.PI / 2;
+ group.add(spike);
+ spikes.push(spike);
+ }
+ portalObj.customElements.spikes = spikes;
+
+ // Darker Swirl
+ swirl.material.uniforms.uColor.value = new THREE.Color(0x220000);
+ }
+
+ return portalObj;
+}
+
+// ═══ PARTICLES ═══
+function createParticles() {
+ const count = particleCount(1500);
+ const geo = new THREE.BufferGeometry();
+ const positions = new Float32Array(count * 3);
+ const colors = new Float32Array(count * 3);
+ const sizes = new Float32Array(count);
+
+ const c1 = new THREE.Color(NEXUS.colors.primary);
+ const c2 = new THREE.Color(NEXUS.colors.secondary);
+ const c3 = new THREE.Color(NEXUS.colors.gold);
+
+ for (let i = 0; i < count; i++) {
+ positions[i * 3] = (Math.random() - 0.5) * 60;
+ positions[i * 3 + 1] = Math.random() * 20;
+ positions[i * 3 + 2] = (Math.random() - 0.5) * 60;
+
+ const t = Math.random();
+ const col = t < 0.5 ? c1.clone().lerp(c2, t * 2) : c2.clone().lerp(c3, (t - 0.5) * 2);
+ colors[i * 3] = col.r;
+ colors[i * 3 + 1] = col.g;
+ colors[i * 3 + 2] = col.b;
+
+ sizes[i] = 0.02 + Math.random() * 0.06;
+ }
+
+ geo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+ geo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+ geo.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
+
+ const mat = new THREE.ShaderMaterial({
+ uniforms: { uTime: { value: 0 } },
+ vertexShader: `
+ attribute float size;
+ attribute vec3 color;
+ varying vec3 vColor;
+ uniform float uTime;
+ void main() {
+ vColor = color;
+ vec3 pos = position;
+ pos.y += sin(uTime * 0.5 + position.x * 0.5) * 0.3;
+ pos.x += sin(uTime * 0.3 + position.z * 0.4) * 0.2;
+ vec4 mv = modelViewMatrix * vec4(pos, 1.0);
+ gl_PointSize = size * 300.0 / -mv.z;
+ gl_Position = projectionMatrix * mv;
+ }
+ `,
+ fragmentShader: `
+ varying vec3 vColor;
+ void main() {
+ float d = length(gl_PointCoord - 0.5);
+ if (d > 0.5) discard;
+ float alpha = smoothstep(0.5, 0.1, d);
+ gl_FragColor = vec4(vColor, alpha * 0.7);
+ }
+ `,
+ transparent: true,
+ depthWrite: false,
+ blending: THREE.AdditiveBlending,
+ });
+
+ particles = new THREE.Points(geo, mat);
+ scene.add(particles);
+}
+
+function createDustParticles() {
+ const count = particleCount(500);
+ const geo = new THREE.BufferGeometry();
+ const positions = new Float32Array(count * 3);
+
+ for (let i = 0; i < count; i++) {
+ positions[i * 3] = (Math.random() - 0.5) * 40;
+ positions[i * 3 + 1] = Math.random() * 15;
+ positions[i * 3 + 2] = (Math.random() - 0.5) * 40;
+ }
+
+ geo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+
+ const mat = new THREE.PointsMaterial({
+ color: 0x8899bb,
+ size: 0.03,
+ transparent: true,
+ opacity: 0.3,
+ depthWrite: false,
+ });
+
+ dustParticles = new THREE.Points(geo, mat);
+ scene.add(dustParticles);
+}
+
+// ═══ AMBIENT STRUCTURES ═══
+function createAmbientStructures() {
+ const crystalMat = new THREE.MeshPhysicalMaterial({
+ color: 0x3355aa,
+ roughness: 0.1,
+ metalness: 0.2,
+ transmission: 0.6,
+ thickness: 2,
+ emissive: 0x1122aa,
+ emissiveIntensity: 0.3,
+ });
+
+ const positions = [
+ { x: -18, z: -15, s: 1.5, ry: 0.3 },
+ { x: -20, z: -10, s: 1, ry: 0.8 },
+ { x: -15, z: -18, s: 2, ry: 1.2 },
+ { x: 18, z: -15, s: 1.8, ry: 2.1 },
+ { x: 20, z: -12, s: 1.2, ry: 0.5 },
+ { x: -12, z: 18, s: 1.3, ry: 1.8 },
+ { x: 14, z: 16, s: 1.6, ry: 0.9 },
+ ];
+
+ positions.forEach(p => {
+ const geo = new THREE.ConeGeometry(0.4 * p.s, 2.5 * p.s, 5);
+ const crystal = new THREE.Mesh(geo, crystalMat.clone());
+ crystal.position.set(p.x, 1.25 * p.s, p.z);
+ crystal.rotation.y = p.ry;
+ crystal.rotation.z = (Math.random() - 0.5) * 0.3;
+ crystal.castShadow = true;
+ scene.add(crystal);
+ });
+
+ for (let i = 0; i < 5; i++) {
+ const angle = (i / 5) * Math.PI * 2;
+ const r = 10;
+ const geo = new THREE.OctahedronGeometry(0.4, 0);
+ const mat = new THREE.MeshStandardMaterial({
+ color: NEXUS.colors.primary,
+ emissive: NEXUS.colors.primary,
+ emissiveIntensity: 0.5,
+ });
+ const stone = new THREE.Mesh(geo, mat);
+ stone.position.set(Math.cos(angle) * r, 5 + Math.sin(i * 1.3) * 1.5, Math.sin(angle) * r);
+ stone.name = 'runestone_' + i;
+ scene.add(stone);
+ }
+
+ const coreGeo = new THREE.IcosahedronGeometry(0.6, 2);
+ const coreMat = new THREE.MeshPhysicalMaterial({
+ color: 0x4af0c0,
+ emissive: 0x4af0c0,
+ emissiveIntensity: 2,
+ roughness: 0,
+ metalness: 1,
+ transmission: 0.3,
+ thickness: 1,
+ });
+ const core = new THREE.Mesh(coreGeo, coreMat);
+ core.position.set(0, 2.5, 0);
+ core.name = 'nexus-core';
+ scene.add(core);
+
+ const pedGeo = new THREE.CylinderGeometry(0.8, 1.2, 1.5, 8);
+ const pedMat = new THREE.MeshStandardMaterial({
+ color: 0x0a0f1a,
+ roughness: 0.4,
+ metalness: 0.8,
+ emissive: 0x1a2a4a,
+ emissiveIntensity: 0.3,
+ });
+ const pedestal = new THREE.Mesh(pedGeo, pedMat);
+ pedestal.position.set(0, 0.75, 0);
+ pedestal.castShadow = true;
+ scene.add(pedestal);
+}
+
+// ═══ NAVIGATION MODE ═══
+// ═══ VISITOR / OPERATOR MODE TOGGLE ═══
+function toggleUIMode() {
+ uiMode = uiMode === 'visitor' ? 'operator' : 'visitor';
+ document.body.classList.remove('visitor-mode', 'operator-mode');
+ document.body.classList.add(uiMode + '-mode');
+ const label = document.getElementById('mode-label');
+ const icon = document.querySelector('#mode-toggle-btn .hud-icon');
+ if (label) label.textContent = uiMode === 'visitor' ? 'VISITOR' : 'OPERATOR';
+ if (icon) icon.textContent = uiMode === 'visitor' ? '👁' : '⚙';
+ addChatMessage('system', `Switched to ${uiMode.toUpperCase()} mode.`);
+}
+
+function cycleNavMode() {
+ navModeIdx = (navModeIdx + 1) % NAV_MODES.length;
+ const mode = NAV_MODES[navModeIdx];
+ if (mode === 'orbit') {
+ const dir = new THREE.Vector3(0, 0, -1).applyEuler(playerRot);
+ orbitState.target.copy(playerPos).addScaledVector(dir, orbitState.radius);
+ orbitState.target.y = Math.max(0, orbitState.target.y);
+ const toCamera = new THREE.Vector3().subVectors(playerPos, orbitState.target);
+ orbitState.radius = toCamera.length();
+ orbitState.theta = Math.atan2(toCamera.x, toCamera.z);
+ orbitState.phi = Math.acos(Math.max(-1, Math.min(1, toCamera.y / orbitState.radius)));
+ }
+ if (mode === 'fly') flyY = playerPos.y;
+ updateNavModeUI(mode);
+}
+
+function updateNavModeUI(mode) {
+ const el = document.getElementById('nav-mode-label');
+ if (el) el.textContent = mode.toUpperCase();
+}
+
+// ═══ CONTROLS ═══
+function setupControls() {
+ document.addEventListener('keydown', (e) => {
+ keys[e.key.toLowerCase()] = true;
+ if (e.key === 'Enter') {
+ e.preventDefault();
+ const input = document.getElementById('chat-input');
+ if (document.activeElement === input) {
+ sendChatMessage();
+ } else {
+ input.focus();
+ }
+ }
+ if (e.key.toLowerCase() === 'm' && document.activeElement !== document.getElementById('chat-input')) {
+ openPortalAtlas();
+ }
+ if (e.key === 'Escape') {
+ document.getElementById('chat-input').blur();
+ if (portalOverlayActive) closePortalOverlay();
+ if (visionOverlayActive) closeVisionOverlay();
+ if (atlasOverlayActive) closePortalAtlas();
+ if (_archiveDashboardOpen) toggleArchiveHealthDashboard();
+ if (_memoryFilterOpen) closeMemoryFilter();
+ }
+ if (e.key.toLowerCase() === 'v' && document.activeElement !== document.getElementById('chat-input')) {
+ cycleNavMode();
+ }
+ if (e.key.toLowerCase() === 'f' && activePortal && !portalOverlayActive) {
+ activatePortal(activePortal);
+ }
+ if (e.key.toLowerCase() === 'e' && activeVisionPoint && !visionOverlayActive) {
+ activateVisionPoint(activeVisionPoint);
+ }
+ if (e.key.toLowerCase() === 'h' && document.activeElement !== document.getElementById('chat-input')) {
+ toggleArchiveHealthDashboard();
+ }
+ if (e.key.toLowerCase() === 'g' && document.activeElement !== document.getElementById('chat-input')) {
+ toggleMemoryFilter();
+ }
+ });
+ document.addEventListener('keyup', (e) => {
+ keys[e.key.toLowerCase()] = false;
+ });
+
+ const canvas = document.getElementById('nexus-canvas');
+ canvas.addEventListener('mousedown', (e) => {
+ if (e.target === canvas) {
+ mouseDown = true;
+ orbitState.lastX = e.clientX;
+ orbitState.lastY = e.clientY;
+ _clickStartX = e.clientX;
+ _clickStartY = e.clientY;
+
+ // Raycasting for portals
+ if (!portalOverlayActive) {
+ const mouse = new THREE.Vector2(
+ (e.clientX / window.innerWidth) * 2 - 1,
+ -(e.clientY / window.innerHeight) * 2 + 1
+ );
+ const raycaster = new THREE.Raycaster();
+ raycaster.setFromCamera(mouse, camera);
+ const intersects = raycaster.intersectObjects(portals.map(p => p.ring));
+ if (intersects.length > 0) {
+ const clickedRing = intersects[0].object;
+ const portal = portals.find(p => p.ring === clickedRing);
+ if (portal) activatePortal(portal);
+ }
+ }
+ }
+ });
+ document.addEventListener('mouseup', (e) => {
+ const wasDrag = Math.abs(e.clientX - _clickStartX) > 5 || Math.abs(e.clientY - _clickStartY) > 5;
+ mouseDown = false;
+ if (wasDrag || e.target !== canvas) return;
+
+ // Crystal click detection (Mnemosyne inspect panel, issue #1227)
+ if (!portalOverlayActive) {
+ const mouse = new THREE.Vector2(
+ (e.clientX / window.innerWidth) * 2 - 1,
+ -(e.clientY / window.innerHeight) * 2 + 1
+ );
+ const raycaster = new THREE.Raycaster();
+ raycaster.setFromCamera(mouse, camera);
+ const crystalMeshes = SpatialMemory.getCrystalMeshes();
+ const hits = raycaster.intersectObjects(crystalMeshes);
+ if (hits.length > 0) {
+ const entry = SpatialMemory.getMemoryFromMesh(hits[0].object);
+ if (entry) {
+ SpatialMemory.highlightMemory(entry.data.id);
+ MemoryPulse.triggerPulse(entry.data.id);
+ const regionDef = SpatialMemory.REGIONS[entry.region] || SpatialMemory.REGIONS.working;
+ MemoryInspect.show(entry.data, regionDef);
+ }
+ } else {
+ // Clicked empty space — close inspect panel and deselect crystal
+ if (MemoryInspect.isOpen()) {
+ SpatialMemory.clearHighlight();
+ MemoryInspect.hide();
+ }
+ }
+ }
+ });
+ document.addEventListener('mousemove', (e) => {
+ if (!mouseDown) return;
+ if (document.activeElement === document.getElementById('chat-input')) return;
+ const mode = NAV_MODES[navModeIdx];
+ if (mode === 'orbit') {
+ const dx = e.clientX - orbitState.lastX;
+ const dy = e.clientY - orbitState.lastY;
+ orbitState.lastX = e.clientX;
+ orbitState.lastY = e.clientY;
+ orbitState.theta -= dx * 0.005;
+ orbitState.phi = Math.max(0.05, Math.min(Math.PI * 0.85, orbitState.phi + dy * 0.005));
+ } else {
+ playerRot.y -= e.movementX * 0.003;
+ playerRot.x -= e.movementY * 0.003;
+ playerRot.x = Math.max(-Math.PI / 3, Math.min(Math.PI / 3, playerRot.x));
+ }
+ });
+
+ canvas.addEventListener('wheel', (e) => {
+ if (NAV_MODES[navModeIdx] === 'orbit') {
+ orbitState.radius = Math.max(orbitState.minR, Math.min(orbitState.maxR, orbitState.radius + e.deltaY * 0.02));
+ }
+ }, { passive: true });
+
+ document.getElementById('chat-toggle').addEventListener('click', () => {
+ chatOpen = !chatOpen;
+ document.getElementById('chat-panel').classList.toggle('collapsed', !chatOpen);
+ });
+ document.getElementById('chat-send').addEventListener('click', () => sendChatMessage());
+
+ // Add MemPalace mining button
+ document.querySelector('.chat-quick-actions').innerHTML += `
+
+
+
Compression: --x
+
Docs: 0
+
AAAK: 0B
+
Compression: --x
+
Docs: 0
+
AAAK: 0B
+
Logs: 0
+
${prefix} ${escHtml(e.text)} ${ts}
`;
+ }).join('');
+}
+
+/**
+ * Process Evennia-specific fields from Hermes WS messages.
+ * Called from handleHermesMessage for any message carrying evennia metadata.
+ */
+function handleEvenniaEvent(data) {
+ if (data.evennia_command) {
+ addActionStreamEntry('cmd', data.evennia_command);
+ }
+ if (data.evennia_result) {
+ const excerpt = typeof data.evennia_result === 'string'
+ ? data.evennia_result.substring(0, 120)
+ : JSON.stringify(data.evennia_result).substring(0, 120);
+ addActionStreamEntry('result', excerpt);
+ }
+ if (data.evennia_room) {
+ setActionStreamRoom(data.evennia_room);
+ addActionStreamEntry('room', `Moved to: ${data.evennia_room}`);
+ }
+}
+
+
+// ═══════════════════════════════════════════
+
+
+// ═══════════════════════════════════════════
+// EVENNIA ROOM SNAPSHOT PANEL (Issue #728)
+// ═══════════════════════════════════════════
+
+function handleEvenniaEvent(data) {
+ const evtType = data.type;
+
+ if (evtType === 'evennia.room_snapshot') {
+ evenniaRoom = {
+ roomKey: data.room_key || data.room_id || '',
+ title: data.title || 'Unknown Room',
+ desc: data.desc || '',
+ exits: data.exits || [],
+ objects: data.objects || [],
+ occupants: data.occupants || [],
+ timestamp: data.timestamp || new Date().toISOString()
+ };
+ evenniaConnected = true;
+ renderEvenniaRoomPanel();
+ resetEvenniaStaleTimer();
+ } else if (evtType === 'evennia.player_move') {
+ // Movement may indicate current room changed; update location text
+ if (data.to_room) {
+ const locEl = document.getElementById('hud-location-text');
+ if (locEl) locEl.textContent = data.to_room;
+ }
+ } else if (evtType === 'evennia.session_bound') {
+ evenniaConnected = true;
+ renderEvenniaRoomPanel();
+ } else if (evtType === 'evennia.player_join' || evtType === 'evennia.player_leave') {
+ // Refresh occupant display if we have room data
+ if (evenniaRoom) renderEvenniaRoomPanel();
+ }
+}
+
+function resetEvenniaStaleTimer() {
+ if (evenniaStaleTimer) clearTimeout(evenniaStaleTimer);
+ const dot = document.getElementById('erp-live-dot');
+ const status = document.getElementById('erp-status');
+ if (dot) dot.className = 'erp-live-dot connected';
+ if (status) { status.textContent = 'LIVE'; status.className = 'erp-status online'; }
+ evenniaStaleTimer = setTimeout(() => {
+ if (dot) dot.className = 'erp-live-dot stale';
+ if (status) { status.textContent = 'STALE'; status.className = 'erp-status stale'; }
+ }, EVENNIA_STALE_MS);
+}
+
+function renderEvenniaRoomPanel() {
+ const panel = document.getElementById('evennia-room-panel');
+ if (!panel) return;
+ panel.style.display = 'block';
+
+ const emptyEl = document.getElementById('erp-empty');
+ const roomEl = document.getElementById('erp-room');
+
+ if (!evenniaRoom) {
+ if (emptyEl) emptyEl.style.display = 'flex';
+ if (roomEl) roomEl.style.display = 'none';
+ return;
+ }
+
+ if (emptyEl) emptyEl.style.display = 'none';
+ if (roomEl) roomEl.style.display = 'block';
+
+ const titleEl = document.getElementById('erp-room-title');
+ const descEl = document.getElementById('erp-room-desc');
+ if (titleEl) titleEl.textContent = evenniaRoom.title;
+ if (descEl) descEl.textContent = evenniaRoom.desc;
+
+ renderEvenniaList('erp-exits', evenniaRoom.exits, (item) => {
+ const name = item.key || item.destination_id || item.name || '?';
+ const dest = item.destination_key || item.destination_id || '';
+ return { icon: '→', label: name, extra: dest && dest !== name ? dest : '' };
+ });
+
+ renderEvenniaList('erp-objects', evenniaRoom.objects, (item) => {
+ const name = item.short_desc || item.key || item.id || item.name || '?';
+ return { icon: '◇', label: name };
+ });
+
+ renderEvenniaList('erp-occupants', evenniaRoom.occupants, (item) => {
+ const name = item.character || item.name || item.account || '?';
+ return { icon: '◉', label: name };
+ });
+
+ const tsEl = document.getElementById('erp-footer-ts');
+ const roomKeyEl = document.getElementById('erp-footer-room');
+ if (tsEl) {
+ try {
+ const d = new Date(evenniaRoom.timestamp);
+ tsEl.textContent = d.toISOString().replace('T', ' ').substring(0, 19) + ' UTC';
+ } catch(e) { tsEl.textContent = '—'; }
+ }
+ if (roomKeyEl) roomKeyEl.textContent = evenniaRoom.roomKey;
+}
+
+function renderEvenniaList(containerId, items, mapFn) {
+ const container = document.getElementById(containerId);
+ if (!container) return;
+ container.innerHTML = '';
+
+ if (!items || items.length === 0) {
+ const empty = document.createElement('div');
+ empty.className = 'erp-section-empty';
+ empty.textContent = 'none';
+ container.appendChild(empty);
+ return;
+ }
+
+ items.forEach(item => {
+ const mapped = mapFn(item);
+ const row = document.createElement('div');
+ row.className = 'erp-item';
+ row.innerHTML = `${mapped.icon}${mapped.label}`;
+ if (mapped.extra) {
+ row.innerHTML += `${mapped.extra}`;
+ }
+ container.appendChild(row);
+ });
+}
+// MNEMOSYNE — LIVE MEMORY BRIDGE
+// ═══════════════════════════════════════════
+
+/**
+ * Handle incoming memory messages from Hermes WS.
+ * Actions: place, remove, update, sync_response
+ */
+
+/**
+ * Clear all entries from the memory feed.
+ */
+function clearMemoryFeed() {
+ memoryFeedEntries = [];
+ renderMemoryFeed();
+ console.info('[Mnemosyne] Memory feed cleared');
+}
+
+/**
+ * Navigate to a linked memory from the inspect panel.
+ * Highlights the target crystal and re-opens the panel with its data.
+ * @param {string} memId
+ */
+function _navigateToMemory(memId) {
+ const all = SpatialMemory.getAllMemories();
+ const data = all.find(m => m.id === memId);
+ if (!data) {
+ console.warn('[MemoryInspect] Linked memory not found in scene:', memId);
+ return;
+ }
+ SpatialMemory.highlightMemory(memId);
+ const regionDef = SpatialMemory.REGIONS[data.category] || SpatialMemory.REGIONS.working;
+ MemoryInspect.show(data, regionDef);
+}
+
+function handleMemoryMessage(data) {
+ const action = data.action;
+ const memory = data.memory;
+ const memories = data.memories;
+
+ if (action === 'place' && memory) {
+ const placed = SpatialMemory.placeMemory(memory);
+ if (placed) {
+ addMemoryFeedEntry('place', memory);
+ console.info('[Mnemosyne] Memory placed via WS:', memory.id);
+ }
+ } else if (action === 'remove' && memory) {
+ SpatialMemory.removeMemory(memory.id);
+ addMemoryFeedEntry('remove', memory);
+ console.info('[Mnemosyne] Memory removed via WS:', memory.id);
+ } else if (action === 'update' && memory) {
+ SpatialMemory.updateMemory(memory.id, memory);
+ addMemoryFeedEntry('update', memory);
+ console.info('[Mnemosyne] Memory updated via WS:', memory.id);
+ } else if (action === 'sync_response' && Array.isArray(memories)) {
+ const count = SpatialMemory.importMemories(memories);
+ addMemoryFeedEntry('sync', { content: count + ' memories synced', id: 'sync' });
+ console.info('[Mnemosyne] Synced', count, 'memories from Hermes');
+ } else {
+ console.warn('[Mnemosyne] Unknown memory action:', action);
+ }
+ if (_archiveDashboardOpen) updateArchiveHealthDashboard();
+}
+
+/**
+ * Add an entry to the memory activity feed panel.
+ */
+function addMemoryFeedEntry(action, memory) {
+ const entry = {
+ action,
+ content: memory.content || memory.id || '(unknown)',
+ category: memory.category || 'working',
+ timestamp: new Date().toISOString()
+ };
+
+ memoryFeedEntries.unshift(entry);
+ if (memoryFeedEntries.length > 5) memoryFeedEntries.pop();
+
+ renderMemoryFeed();
+
+ // Auto-dismiss entries older than 5 minutes
+ setTimeout(() => {
+ const idx = memoryFeedEntries.indexOf(entry);
+ if (idx > -1) {
+ memoryFeedEntries.splice(idx, 1);
+ renderMemoryFeed();
+ }
+ }, 300000);
+}
+
+/**
+ * Render the memory feed panel.
+ */
+function renderMemoryFeed() {
+ const container = document.getElementById('memory-feed-list');
+ if (!container) return;
+
+ container.innerHTML = '';
+ memoryFeedEntries.forEach(entry => {
+ const el = document.createElement('div');
+ el.className = 'memory-feed-entry memory-feed-' + entry.action;
+
+ const regionDef = SpatialMemory.REGIONS[entry.category] || SpatialMemory.REGIONS.working;
+ const dotColor = '#' + regionDef.color.toString(16).padStart(6, '0');
+ const time = new Date(entry.timestamp).toLocaleTimeString();
+ const truncated = entry.content.length > 40 ? entry.content.slice(0, 40) + '\u2026' : entry.content;
+ const actionIcon = { place: '\u2795', remove: '\u2796', update: '\u270F', sync: '\u21C4' }[entry.action] || '\u2022';
+
+ el.innerHTML = '' +
+ '' + actionIcon + '' +
+ '' + truncated + '' +
+ '' + time + '';
+
+ container.appendChild(el);
+ });
+
+ // Show feed if there are entries
+ const panel = document.getElementById('memory-feed');
+ if (panel) panel.style.display = memoryFeedEntries.length > 0 ? 'block' : 'none';
+}
+
+
+// ── Archive Health Dashboard (issue #1210) ────────────────────────────
+
+let _archiveDashboardOpen = false;
+
+/**
+ * Toggle the archive health dashboard panel (hotkey H).
+ */
+function toggleArchiveHealthDashboard() {
+ _archiveDashboardOpen = !_archiveDashboardOpen;
+ const panel = document.getElementById('archive-health-dashboard');
+ if (!panel) return;
+ if (_archiveDashboardOpen) {
+ updateArchiveHealthDashboard();
+ panel.style.display = 'block';
+ } else {
+ panel.style.display = 'none';
+ }
+}
+
+/**
+ * Render current archive statistics into the dashboard panel.
+ * Reads live from SpatialMemory.getAllMemories() — no backend needed.
+ */
+function toggleMemoryFilter() {
+ _memoryFilterOpen = !_memoryFilterOpen;
+ if (_memoryFilterOpen) {
+ openMemoryFilter();
+ } else {
+ closeMemoryFilter();
+ }
+}
+
+function updateArchiveHealthDashboard() {
+ const container = document.getElementById('archive-health-content');
+ if (!container) return;
+
+ const memories = SpatialMemory.getAllMemories();
+ const regions = SpatialMemory.REGIONS;
+ const total = memories.length;
+
+ // ── Category breakdown ────────────────────────────────────────────
+ const catCounts = {};
+ memories.forEach(m => {
+ const cat = m.category || 'working';
+ catCounts[cat] = (catCounts[cat] || 0) + 1;
+ });
+
+ // ── Trust distribution (using strength field as trust score) ──────
+ let trustHigh = 0, trustMid = 0, trustLow = 0;
+ memories.forEach(m => {
+ const t = m.strength != null ? m.strength : 0.7;
+ if (t > 0.8) trustHigh++;
+ else if (t >= 0.5) trustMid++;
+ else trustLow++;
+ });
+
+ // ── Timestamps ────────────────────────────────────────────────────
+ let newestMs = null, oldestMs = null;
+ memories.forEach(m => {
+ const ts = m.timestamp ? new Date(m.timestamp).getTime() : null;
+ if (ts && !isNaN(ts)) {
+ if (newestMs === null || ts > newestMs) newestMs = ts;
+ if (oldestMs === null || ts < oldestMs) oldestMs = ts;
+ }
+ });
+ const fmtDate = ms => ms ? new Date(ms).toLocaleString(undefined, { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }) : '—';
+
+ // ── Entity connection count ───────────────────────────────────────
+ let entityConnCount = 0;
+ memories.forEach(m => {
+ if (m.connections && Array.isArray(m.connections)) {
+ entityConnCount += m.connections.length;
+ }
+ });
+ // Each connection is stored on both ends, divide by 2 for unique links
+ const uniqueLinks = Math.floor(entityConnCount / 2);
+
+ // ── Build HTML ────────────────────────────────────────────────────
+ let html = '';
+
+ // Total count
+ html += `
+
Total Memories
+
+ ${total}
+ crystals in archive
+
+
Categories
`;
+ sortedCats.forEach(([cat, count]) => {
+ const region = regions[cat] || regions.working;
+ const color = '#' + region.color.toString(16).padStart(6, '0');
+ const pct = total > 0 ? Math.round((count / total) * 100) : 0;
+ html += `
+
+
${region.label || cat}
+
+
${count}
+
`;
+ });
+ html += `
+
Trust Distribution
+
+
+
${trustHigh}
+
High >0.8
+
+
+
${trustMid}
+
Mid 0.5–0.8
+
+
+
${trustLow}
+
Low <0.5
+
+
+
+
Timeline
+
+
+ Newest
+ ${fmtDate(newestMs)}
+
+
+ Oldest
+ ${fmtDate(oldestMs)}
+
+
+
+
Entity Connections
+
${uniqueLinks}
+
unique links
+
PRESS H TO CLOSE
`;
+
+ container.innerHTML = html;
+}
+
+function updateWsHudStatus(connected) {
+ // Update MemPalace status alongside regular WS status
+ updateMemPalaceStatus();
+ // Existing WS status code...
+ // Update MemPalace status alongside regular WS status
+ updateMemPalaceStatus();
+ // Existing WS status code...
+ const dot = document.querySelector('.chat-status-dot');
+ if (dot) {
+ dot.style.background = connected ? '#4af0c0' : '#ff4466';
+ dot.style.boxShadow = connected ? '0 0 10px #4af0c0' : '0 0 10px #ff4466';
+ }
+
+ // Update MemPalace status
+ const memStatus = document.getElementById('mem-palace-status');
+ if (memStatus) {
+ memStatus.textContent = connected ? 'MEMPALACE ACTIVE' : 'MEMPALACE OFFLINE';
+ memStatus.style.color = connected ? '#4af0c0' : '#ff4466';
+ }
+}
+
+function connectMemPalace() {
+ const statusEl = document.getElementById('mem-palace-status');
+ const ratioEl = document.getElementById('compression-ratio');
+ const docsEl = document.getElementById('docs-mined');
+ const sizeEl = document.getElementById('aaak-size');
+
+ // Show connecting state
+ if (statusEl) {
+ statusEl.textContent = 'MEMPALACE CONNECTING';
+ statusEl.style.color = '#ffd700';
+ statusEl.style.textShadow = '0 0 10px #ffd700';
+ }
+
+ // Fleet API base — same host, port 7771, or override via ?mempalace=host:port
+ const params = new URLSearchParams(window.location.search);
+ const override = params.get('mempalace');
+ const apiBase = override
+ ? `http://${override}`
+ : `${window.location.protocol}//${window.location.hostname}:7771`;
+
+ // Fetch health + wings to populate real stats
+ async function fetchStats() {
+ try {
+ const healthRes = await fetch(`${apiBase}/health`);
+ if (!healthRes.ok) throw new Error(`Health ${healthRes.status}`);
+ const health = await healthRes.json();
+
+ const wingsRes = await fetch(`${apiBase}/wings`);
+ const wings = wingsRes.ok ? await wingsRes.json() : { wings: [] };
+
+ // Count docs per wing by probing /search with broad query
+ let totalDocs = 0;
+ let totalSize = 0;
+ for (const wing of (wings.wings || [])) {
+ try {
+ const sr = await fetch(`${apiBase}/search?q=*&wing=${wing}&n=1`);
+ if (sr.ok) {
+ const sd = await sr.json();
+ totalDocs += sd.count || 0;
+ }
+ } catch (_) { /* skip */ }
+ }
+
+ const compressionRatio = totalDocs > 0 ? Math.max(1, Math.round(totalDocs * 0.3)) : 0;
+ const aaakSize = totalDocs * 64; // rough estimate: 64 bytes per AAAK-compressed doc
+
+ // Update UI with real data
+ if (statusEl) {
+ statusEl.textContent = 'MEMPALACE ACTIVE';
+ statusEl.style.color = '#4af0c0';
+ statusEl.style.textShadow = '0 0 10px #4af0c0';
+ }
+ if (ratioEl) ratioEl.textContent = `${compressionRatio}x`;
+ if (docsEl) docsEl.textContent = String(totalDocs);
+ if (sizeEl) sizeEl.textContent = formatBytes(aaakSize);
+
+ console.log(`[MemPalace] Connected to ${apiBase} — ${totalDocs} docs across ${wings.wings?.length || 0} wings`);
+ return true;
+ } catch (err) {
+ console.warn('[MemPalace] Fleet API unavailable:', err.message);
+ if (statusEl) {
+ statusEl.textContent = 'MEMPALACE OFFLINE';
+ statusEl.style.color = '#ff4466';
+ statusEl.style.textShadow = '0 0 10px #ff4466';
+ }
+ if (ratioEl) ratioEl.textContent = '--x';
+ if (docsEl) docsEl.textContent = '0';
+ if (sizeEl) sizeEl.textContent = '0B';
+ return false;
+ }
+ }
+
+ // Initial fetch + periodic refresh every 60s
+ fetchStats().then(ok => {
+ if (ok) setInterval(fetchStats, 60000);
+ });
+}
+
+function formatBytes(bytes) {
+ if (bytes === 0) return '0B';
+ const k = 1024;
+ const sizes = ['B', 'KB', 'MB', 'GB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + sizes[i];
+}
+
+function mineMemPalaceContent() {
+ const logs = document.getElementById('mem-palace-logs');
+ const now = new Date().toLocaleTimeString();
+
+ // Add mining progress indicator
+ logs.innerHTML = `${now} - Mining chat history...
` + logs.innerHTML;
+
+ // Get chat messages to mine
+ const messages = Array.from(document.querySelectorAll('.chat-msg')).map(m => m.innerText);
+ if (messages.length === 0) {
+ logs.innerHTML = `${now} - No chat content to mine
` + logs.innerHTML;
+ return;
+ }
+
+ // Update MemPalace stats
+ const ratio = parseInt(document.getElementById('compression-ratio').textContent) + 1;
+ const docs = parseInt(document.getElementById('docs-mined').textContent) + messages.length;
+ const size = parseInt(document.getElementById('aaak-size').textContent.replace('B','')) + (messages.length * 30);
+
+ document.getElementById('compression-ratio').textContent = `${ratio}x`;
+ document.getElementById('docs-mined').textContent = `${docs}`;
+ document.getElementById('aaak-size').textContent = `${size}B`;
+
+ // Add success message
+ logs.innerHTML = `${now} - Mined ${messages.length} chat entries
` + logs.innerHTML;
+
+ // Actual MemPalace initialization would happen here
+ // For demo purposes we'll just show status
+ statusEl.textContent = 'Connected to local MemPalace';
+ statusEl.style.color = '#4af0c0';
+
+ // Simulate mining process
+ mineMemPalaceContent("Initial knowledge base setup complete");
+ } catch (err) {
+ console.error('Failed to initialize MemPalace:', err);
+ document.getElementById('mem-palace-status').textContent = 'MemPalace ERROR';
+ document.getElementById('mem-palace-status').style.color = '#ff4466';
+ }
+ try {
+ // Initialize MemPalace MCP server
+ console.log('Initializing MemPalace memory system...');
+ // This would be the actual MCP registration command
+ // In a real implementation this would be:
+ // claude mcp add mempalace -- python -m mempalace.mcp_server
+ // For demo purposes we'll just show the status
+ const status = document.getElementById('mem-palace-status');
+ if (status) {
+ status.textContent = 'MEMPALACE INITIALIZING';
+ setTimeout(() => {
+ status.textContent = 'MEMPALACE ACTIVE';
+ status.style.color = '#4af0c0';
+ }, 1500);
+ }
+ } catch (err) {
+ console.error('Failed to initialize MemPalace:', err);
+ const status = document.getElementById('mem-palace-status');
+ if (status) {
+ status.textContent = 'MEMPALACE ERROR';
+ status.style.color = '#ff4466';
+ }
+ }
+}
+
+// ═══ SESSION PERSISTENCE ═══
+function saveSession() {
+ const msgs = Array.from(document.querySelectorAll('.chat-msg')).slice(-60).map(el => ({
+ html: el.innerHTML,
+ className: el.className
+ }));
+
+ // Store in MemPalace
+ if (window.mempalace) {
+ try {
+ mempalace.add_drawer('chat_history', {
+ content: JSON.stringify(msgs),
+ metadata: {
+ type: 'chat',
+ timestamp: Date.now()
+ }
+ });
+ } catch (error) {
+ console.error('MemPalace save failed:', error);
+ }
+ }
+
+ // Fallback to localStorage
+ localStorage.setItem('nexus_chat_history', JSON.stringify(msgs));
+}
+
+function loadSession() {
+ const saved = localStorage.getItem('nexus_chat_history');
+ if (saved) {
+ const msgs = JSON.parse(saved);
+ const container = document.getElementById('chat-messages');
+ container.innerHTML = '';
+ msgs.forEach(m => {
+ const div = document.createElement('div');
+ div.className = m.className;
+ div.innerHTML = m.html;
+ container.appendChild(div);
+ });
+ container.scrollTop = container.scrollHeight;
+ }
+}
+
+function addChatMessage(agent, text, shouldSave = true) {
+ // Mine chat messages for MemPalace
+ mineMemPalaceContent(text);
+ // Mine chat messages for MemPalace
+ mineMemPalaceContent(text);
+ const container = document.getElementById('chat-messages');
+ const div = document.createElement('div');
+ div.className = `chat-msg chat-msg-${agent}`;
+
+ // Store in MemPalace
+ if (window.mempalace) {
+ mempalace.add_drawer('chat_history', {
+ content: text,
+ metadata: {
+ agent,
+ timestamp: Date.now()
+ }
+ });
+ }
+
+ // Store in MemPalace
+ if (agent !== 'system') {
+ // In a real implementation, we'd use mempalace.add_drawer()
+ console.log(`MemPalace storage: ${agent} - ${text}`);
+ }
+
+ const prefixes = {
+ user: '[ALEXANDER]',
+ timmy: '[TIMMY]',
+ system: '[NEXUS]',
+ error: '[ERROR]',
+ kimi: '[KIMI]',
+ claude: '[CLAUDE]',
+ perplexity: '[PERPLEXITY]'
+ };
+
+ const prefix = document.createElement('span');
+ prefix.className = 'chat-msg-prefix';
+ prefix.textContent = `${prefixes[agent] || '[' + agent.toUpperCase() + ']'} `;
+
+ div.appendChild(prefix);
+ div.appendChild(document.createTextNode(text));
+
+ container.appendChild(div);
+ container.scrollTop = container.scrollHeight;
+
+ if (shouldSave) saveSession();
+}
+
+function addToolMessage(agent, type, content, shouldSave = true) {
+ const container = document.getElementById('chat-messages');
+ const div = document.createElement('div');
+ div.className = `chat-msg chat-msg-tool tool-${type}`;
+
+ const prefix = document.createElement('div');
+ prefix.className = 'chat-msg-prefix';
+ prefix.textContent = `[${agent.toUpperCase()} TOOL ${type.toUpperCase()}]`;
+
+ const pre = document.createElement('pre');
+ pre.className = 'tool-content';
+ pre.textContent = content;
+
+ div.appendChild(prefix);
+ div.appendChild(pre);
+
+ container.appendChild(div);
+ container.scrollTop = container.scrollHeight;
+
+ if (shouldSave) saveSession();
+}
+
+// ═══ PORTAL INTERACTION ═══
+function checkPortalProximity() {
+ if (portalOverlayActive) return;
+
+ let closest = null;
+ let minDist = Infinity;
+
+ portals.forEach(portal => {
+ const dist = playerPos.distanceTo(portal.group.position);
+ if (dist < 4.5 && dist < minDist) {
+ minDist = dist;
+ closest = portal;
+ }
+ });
+
+ activePortal = closest;
+ const hint = document.getElementById('portal-hint');
+ if (activePortal) {
+ document.getElementById('portal-hint-name').textContent = activePortal.config.name;
+ hint.style.display = 'flex';
+ } else {
+ hint.style.display = 'none';
+ }
+}
+
+function activatePortal(portal) {
+ portalOverlayActive = true;
+ const overlay = document.getElementById('portal-overlay');
+ const nameDisplay = document.getElementById('portal-name-display');
+ const descDisplay = document.getElementById('portal-desc-display');
+ const redirectBox = document.getElementById('portal-redirect-box');
+ const errorBox = document.getElementById('portal-error-box');
+ const timerDisplay = document.getElementById('portal-timer');
+ const statusDot = document.getElementById('portal-status-dot');
+
+ nameDisplay.textContent = portal.config.name.toUpperCase();
+ descDisplay.textContent = portal.config.description;
+ statusDot.style.background = portal.config.color;
+ statusDot.style.boxShadow = `0 0 10px ${portal.config.color}`;
+
+ overlay.style.display = 'flex';
+
+ if (portal.config.destination && portal.config.destination.url) {
+ redirectBox.style.display = 'block';
+ errorBox.style.display = 'none';
+
+ let count = 5;
+ timerDisplay.textContent = count;
+ const interval = setInterval(() => {
+ count--;
+ timerDisplay.textContent = count;
+ if (count <= 0) {
+ clearInterval(interval);
+ if (portalOverlayActive) window.location.href = portal.config.destination.url;
+ }
+ if (!portalOverlayActive) clearInterval(interval);
+ }, 1000);
+ } else {
+ redirectBox.style.display = 'none';
+ errorBox.style.display = 'block';
+ }
+}
+
+function closePortalOverlay() {
+ portalOverlayActive = false;
+ document.getElementById('portal-overlay').style.display = 'none';
+}
+
+// ═══ VISION INTERACTION ═══
+function checkVisionProximity() {
+ if (visionOverlayActive) return;
+
+ let closest = null;
+ let minDist = Infinity;
+
+ visionPoints.forEach(vp => {
+ const dist = playerPos.distanceTo(vp.group.position);
+ if (dist < 3.5 && dist < minDist) {
+ minDist = dist;
+ closest = vp;
+ }
+ });
+
+ activeVisionPoint = closest;
+ const hint = document.getElementById('vision-hint');
+ if (activeVisionPoint) {
+ document.getElementById('vision-hint-title').textContent = activeVisionPoint.config.title;
+ hint.style.display = 'flex';
+ } else {
+ hint.style.display = 'none';
+ }
+}
+
+function activateVisionPoint(vp) {
+ visionOverlayActive = true;
+ const overlay = document.getElementById('vision-overlay');
+ const titleDisplay = document.getElementById('vision-title-display');
+ const contentDisplay = document.getElementById('vision-content-display');
+ const statusDot = document.getElementById('vision-status-dot');
+
+ titleDisplay.textContent = vp.config.title.toUpperCase();
+ contentDisplay.textContent = vp.config.content;
+ statusDot.style.background = vp.config.color;
+ statusDot.style.boxShadow = `0 0 10px ${vp.config.color}`;
+
+ overlay.style.display = 'flex';
+}
+
+function closeVisionOverlay() {
+ visionOverlayActive = false;
+ document.getElementById('vision-overlay').style.display = 'none';
+}
+
+// ═══ PORTAL ATLAS / WORLD DIRECTORY ═══
+let atlasActiveFilter = 'all';
+let atlasSearchQuery = '';
+
+function openPortalAtlas() {
+ atlasOverlayActive = true;
+ document.getElementById('atlas-overlay').style.display = 'flex';
+ populateAtlas();
+ // Focus search input
+ setTimeout(() => document.getElementById('atlas-search')?.focus(), 100);
+}
+
+function closePortalAtlas() {
+ atlasOverlayActive = false;
+ document.getElementById('atlas-overlay').style.display = 'none';
+ atlasSearchQuery = '';
+ atlasActiveFilter = 'all';
+}
+
+function initAtlasControls() {
+ const searchInput = document.getElementById('atlas-search');
+ if (searchInput) {
+ searchInput.addEventListener('input', (e) => {
+ atlasSearchQuery = e.target.value.toLowerCase().trim();
+ populateAtlas();
+ });
+ }
+
+ const filterBtns = document.querySelectorAll('.atlas-filter-btn');
+ filterBtns.forEach(btn => {
+ btn.addEventListener('click', () => {
+ filterBtns.forEach(b => b.classList.remove('active'));
+ btn.classList.add('active');
+ atlasActiveFilter = btn.dataset.filter;
+ populateAtlas();
+ });
+ });
+}
+
+function matchesAtlasFilter(config) {
+ if (atlasActiveFilter === 'all') return true;
+ if (atlasActiveFilter === 'harness') return (config.portal_type || 'harness') === 'harness' || !config.portal_type;
+ if (atlasActiveFilter === 'game-world') return config.portal_type === 'game-world';
+ return config.status === atlasActiveFilter;
+}
+
+function matchesAtlasSearch(config) {
+ if (!atlasSearchQuery) return true;
+ const haystack = [config.name, config.description, config.id,
+ config.world_category, config.portal_type, config.destination?.type]
+ .filter(Boolean).join(' ').toLowerCase();
+ return haystack.includes(atlasSearchQuery);
+}
+
+function populateAtlas() {
+ const grid = document.getElementById('atlas-grid');
+ grid.innerHTML = '';
+
+ let onlineCount = 0;
+ let standbyCount = 0;
+ let downloadedCount = 0;
+ let visibleCount = 0;
+
+ let readyCount = 0;
+
+ portals.forEach(portal => {
+ const config = portal.config;
+ if (config.status === 'online') onlineCount++;
+ if (config.status === 'standby') standbyCount++;
+ if (config.status === 'downloaded') downloadedCount++;
+
+ if (!matchesAtlasFilter(config) || !matchesAtlasSearch(config)) return;
+ visibleCount++;
+
+ if (config.interaction_ready && config.status === 'online') readyCount++;
+
+ const card = document.createElement('div');
+ card.className = 'atlas-card';
+ card.style.setProperty('--portal-color', config.color);
+
+ const statusClass = `status-${config.status || 'online'}`;
+ const statusLabel = (config.status || 'ONLINE').toUpperCase();
+ const portalType = config.portal_type || 'harness';
+ const categoryLabel = config.world_category
+ ? config.world_category.replace(/-/g, ' ').toUpperCase()
+ : portalType.replace(/-/g, ' ').toUpperCase();
+
+ // Readiness bar for game-worlds
+ let readinessHTML = '';
+ if (config.readiness_steps) {
+ const steps = Object.values(config.readiness_steps);
+ readinessHTML = ``;
+ steps.forEach(step => {
+ readinessHTML += `
`;
+ });
+ readinessHTML += '
${config.description}
+ ${readinessHTML}
+
+
${agents.length > 0 ? 'Agents: ' + presenceLabel : presenceLabel}
+
${readyLabel}
+