feat: feed Evennia world events into Nexus websocket bridge

CLAUDE.md

@@ -2,77 +2,79 @@
 
 ## Project Overview
 
-The Nexus is a Three.js environment — Timmy's sovereign home in 3D space. It serves as the central hub for all portals to other worlds. Stack: vanilla JS ES modules, Three.js 0.183, no bundler.
+The Nexus is Timmy's canonical 3D/home-world repo.
+Its intended role is:
+- local-first training ground for Timmy
+- wizardly visualization surface for the system
 
-## Architecture
+## Current Repo Truth
 
-```
-index.html    # Entry point: HUD, chat panel, loading screen, live-reload script
-style.css     # Design system: dark space theme, holographic panels
-app.js        # Three.js scene, shaders, controls, game loop, WS bridge (~all logic)
-portals.json  # Portal registry (data-driven)
-vision.json   # Vision point content (data-driven)
-server.js     # Optional: proxy server for CORS (commit heatmap API)
-```
+Do not describe this repo as a live browser app on `main`.
 
-No build step. Served as static files. Import maps in `index.html` handle Three.js resolution.
+Current `main` does not ship the old root frontend files:
+- `index.html`
+- `app.js`
+- `style.css`
+- `package.json`
 
-## WebSocket Bridge (v2.0)
+A clean checkout of current `main` serves a directory listing if you static-serve the repo root.
+That is world-state truth.
 
-The Nexus connects to Timmy's backend via WebSocket for live cognitive state:
+The live browser shell people remember exists in legacy form at:
+- `/Users/apayne/the-matrix`
 
-- **URL**: `?ws=ws://hermes:8765` query param, or default `ws://localhost:8765`
-- **Inbound**: `agent_state`, `agent_move`, `chat_response`, `system_metrics`, `dual_brain`, `heartbeat`
-- **Outbound**: `chat_message`, `presence`
-- **Graceful degradation**: When WS is offline, agents idle locally, chat shows "OFFLINE"
+That legacy app is source material for migration, not a second canonical repo.
 
-## The Hard Rule — Read This First
+Timmy_Foundation/the-nexus is the only canonical 3D repo.
 
-**Every PR: net ≤ 10 added lines.** Add 40, remove 30. Can't remove? Import instead.
-You MUST plan your cuts BEFORE writing new code. See CONTRIBUTING.md.
-Do NOT self-merge. Do NOT submit a PR that violates this.
+See:
+- `LEGACY_MATRIX_AUDIT.md`
+- issues `#684`, `#685`, `#686`, `#687`
 
-## Conventions
+## Architecture (current main)
 
-- **ES modules only** — no CommonJS, no bundler
-- **Single-file app** — logic lives in `app.js`; don't split without good reason
-- **Color palette** — defined in `NEXUS.colors` at top of `app.js`
-- **Line budget** — app.js should stay under 1500 lines
-- **Conventional commits**: `feat:`, `fix:`, `refactor:`, `test:`, `chore:`
-- **Branch naming**: `claude/issue-{N}` (e.g. `claude/issue-5`)
-- **One PR at a time** — wait for merge-bot before opening the next
+Current repo contents are centered on:
+- `nexus/` — Python cognition / heartbeat components
+- `server.py` — local websocket bridge
+- `portals.json`, `vision.json` — data/config artifacts
+- deployment/docs files
 
-## Validation (merge-bot checks)
+Do not tell contributors to run Vite or edit a nonexistent root frontend on current `main`.
+If browser/UI work is being restored, it must happen through the migration backlog and land back here.
 
-The `nexus-merge-bot.sh` validates PRs before auto-merge:
+## Hard Rules
 
-1. HTML validation — `index.html` must be valid HTML
-2. JS syntax — `node --check app.js` must pass
-3. JSON validation — any `.json` files must parse
-4. File size budget — JS files must be < 500 KB
+1. One canonical 3D repo only: `Timmy_Foundation/the-nexus`
+2. No parallel evolution of `/Users/apayne/the-matrix` as if it were the product
+3. Rescue useful legacy Matrix work by auditing and migrating it here
+4. Telemetry and durable truth flow through Hermes harness
+5. OpenClaw remains a sidecar, not the governing authority
+6. Before claiming visual validation, prove the app being viewed actually comes from current `the-nexus`
 
-**Always run `node --check app.js` before committing.**
+## Validation Rule
 
-## PR Rules
+If you are asked to visually validate Nexus:
+- prove the tested app comes from a clean checkout/worktree of `Timmy_Foundation/the-nexus`
+- if current `main` only serves a directory listing or otherwise lacks the browser world, stop calling it visually validated
+- pivot to migration audit and issue triage instead of pretending the world still exists
 
-- **Net addition limit: ≤ 10 lines.** No exceptions. Plan cuts before writing.
-- **Do NOT self-merge.** Submit the PR, a different user merges it.
-- Base every PR on latest `main`
-- Squash merge only
-- Include manual test plan + automated test output in PR body
-- Include `Fixes #N` or `Refs #N` in commit message
+## Migration Priorities
 
-## Running Locally
+1. `#684` — docs truth
+2. `#685` — legacy Matrix preservation audit
+3. `#686` — browser smoke / visual validation rebuild
+4. `#687` — restore wizardly local-first visual shell
+5. then continue portal/gameplay work (`#672`, `#673`, `#674`, `#675`)
 
-```bash
-npx serve . -l 3000
-# open http://localhost:3000
-# To connect to Timmy: http://localhost:3000?ws=ws://hermes:8765
-```
+## Legacy Matrix rescue targets
 
-## Gitea API
+The old Matrix contains real quality work worth auditing:
+- visitor movement and embodiment
+- agent presence / bark / chat systems
+- transcript logging
+- ambient world systems
+- satflow / economy visualization
+- browser smoke tests and production build discipline
 
-```
-Base URL: http://143.198.27.163:3000/api/v1
-Repo:     Timmy_Foundation/the-nexus
-```
+Preserve the good work.
+Do not preserve stale assumptions or fake architecture.

EVENNIA_NEXUS_EVENT_PROTOCOL.md

@@ -0,0 +1,107 @@
+# Evennia → Nexus Event Protocol
+
+This is the thin semantic adapter between Timmy's persistent Evennia world and
+Timmy's Nexus-facing world model.
+
+Principle:
+- Evennia owns persistent world truth.
+- Nexus owns visualization and operator legibility.
+- The adapter owns only translation, not storage or game logic.
+
+## Canonical event families
+
+### 1. `evennia.session_bound`
+Binds a Hermes session to a world interaction run.
+
+```json
+{
+  "type": "evennia.session_bound",
+  "hermes_session_id": "20260328_132016_7ea250",
+  "evennia_account": "Timmy",
+  "evennia_character": "Timmy",
+  "timestamp": "2026-03-28T20:00:00Z"
+}
+```
+
+### 2. `evennia.actor_located`
+Declares where Timmy currently is.
+
+```json
+{
+  "type": "evennia.actor_located",
+  "actor_id": "Timmy",
+  "room_id": "Gate",
+  "room_key": "Gate",
+  "room_name": "Gate",
+  "timestamp": "2026-03-28T20:00:01Z"
+}
+```
+
+### 3. `evennia.room_snapshot`
+The main room-state payload Nexus should render.
+
+```json
+{
+  "type": "evennia.room_snapshot",
+  "room_id": "Chapel",
+  "room_key": "Chapel",
+  "title": "Chapel",
+  "desc": "A quiet room set apart for prayer, conscience, grief, and right alignment.",
+  "exits": [
+    {"key": "courtyard", "destination_id": "Courtyard", "destination_key": "Courtyard"}
+  ],
+  "objects": [
+    {"id": "Book of the Soul", "key": "Book of the Soul", "short_desc": "A doctrinal anchor."},
+    {"id": "Prayer Wall", "key": "Prayer Wall", "short_desc": "A place for names and remembered burdens."}
+  ],
+  "occupants": [],
+  "timestamp": "2026-03-28T20:00:02Z"
+}
+```
+
+### 4. `evennia.command_issued`
+Records what Timmy attempted.
+
+```json
+{
+  "type": "evennia.command_issued",
+  "hermes_session_id": "20260328_132016_7ea250",
+  "actor_id": "Timmy",
+  "command_text": "look Book of the Soul",
+  "timestamp": "2026-03-28T20:00:03Z"
+}
+```
+
+### 5. `evennia.command_result`
+Records what the world returned.
+
+```json
+{
+  "type": "evennia.command_result",
+  "hermes_session_id": "20260328_132016_7ea250",
+  "actor_id": "Timmy",
+  "command_text": "look Book of the Soul",
+  "output_text": "Book of the Soul. A doctrinal anchor. It is not decorative; it is a reference point.",
+  "success": true,
+  "timestamp": "2026-03-28T20:00:04Z"
+}
+```
+
+## What Nexus should care about
+
+For first renderability, Nexus only needs:
+- current room title/description
+- exits
+- visible objects
+- actor location
+- latest command/result
+
+It does *not* need raw telnet noise or internal Evennia database structure.
+
+## Ownership boundary
+
+Do not build a second world model in Nexus.
+Do not make Nexus authoritative over persistent state.
+Do not make Evennia care about Three.js internals.
+
+Own only this translation layer.

FIRST_LIGHT_REPORT_EVENNIA_BRIDGE.md

@@ -0,0 +1,49 @@
+# First Light Report — Evennia to Nexus Bridge
+
+Issue:
+- #727 Feed Evennia room/command events into the Nexus websocket bridge
+
+What was implemented:
+- `nexus/evennia_ws_bridge.py` — reads Evennia telemetry JSONL and publishes normalized Evennia→Nexus events into the local websocket bridge
+- `EVENNIA_NEXUS_EVENT_PROTOCOL.md` — canonical event family contract
+- `nexus/evennia_event_adapter.py` — normalization helpers (already merged in #725)
+- `nexus/perception_adapter.py` support for `evennia.actor_located`, `evennia.room_snapshot`, and `evennia.command_result`
+- tests locking the bridge parsing and event contract
+
+Proof method:
+1. Start local Nexus websocket bridge on `ws://127.0.0.1:8765`
+2. Open a websocket listener
+3. Replay a real committed Evennia example trace from `timmy-home`
+4. Confirm normalized events are received over the websocket
+
+Observed received messages (excerpt):
+```json
+[
+  {
+    "type": "evennia.session_bound",
+    "hermes_session_id": "world-basics-trace.example",
+    "evennia_account": "Timmy",
+    "evennia_character": "Timmy"
+  },
+  {
+    "type": "evennia.command_issued",
+    "actor_id": "timmy",
+    "command_text": "look"
+  },
+  {
+    "type": "evennia.command_result",
+    "actor_id": "timmy",
+    "command_text": "look",
+    "output_text": "Chapel A quiet room set apart for prayer, conscience, grief, and right alignment...",
+    "success": true
+  }
+]
+```
+
+Interpretation:
+- Evennia world telemetry can now be published into the Nexus websocket bridge without inventing a second world model.
+- The bridge is thin: it translates and forwards.
+- Nexus-side perception code can now consume these events as part of Timmy's sensorium.
+
+Why this matters:
+This is the first live seam where Timmy's persistent Evennia place can begin to appear inside the Nexus-facing world model.

GAMEPORTAL_PROTOCOL.md

@@ -102,22 +102,47 @@ A portal is a game configuration. To add one:
   "name": "New Game",
   "description": "What this portal is.",
   "status": "offline",
+  "portal_type": "game-world",
+  "world_category": "rpg",
+  "environment": "staging",
+  "access_mode": "operator",
+  "readiness_state": "prototype",
+  "telemetry_source": "hermes-harness:new-game-bridge",
+  "owner": "Timmy",
   "app_id": 12345,
   "window_title": "New Game Window Title",
   "destination": {
     "type": "harness",
+    "action_label": "Enter New Game",
     "params": { "world": "new-world" }
   }
 }
 ```
 
-2. **No code changes.** The heartbeat loop reads `portals.json`,
-   uses `app_id` for Steam API calls and `window_title` for
-   screenshot targeting. The MCP tools are game-agnostic.
+Required metadata fields:
+- `portal_type` — high-level kind (`game-world`, `operator-room`, `research-space`, `experiment`)
+- `world_category` — subtype for navigation and grouping (`rpg`, `workspace`, `sim`, etc.)
+- `environment` — `production`, `staging`, or `local`
+- `access_mode` — `public`, `operator`, or `local-only`
+- `readiness_state` — `playable`, `active`, `prototype`, `rebuilding`, `blocked`, `offline`
+- `telemetry_source` — where truth/status comes from
+- `owner` — who currently owns the world or integration lane
+- `destination.action_label` — human-facing action text for UI cards/directories
+
+2. **No mandatory game-specific code changes.** The heartbeat loop reads `portals.json`,
+   uses metadata for grouping/status/visibility, and can still use fields like
+   `app_id` and `window_title` for screenshot targeting where relevant. The MCP tools remain game-agnostic.
 
 3. **Game-specific prompts** go in `training/data/prompts_*.yaml`
    to teach the model what the game looks like and how to play it.
 
+4. **Migration from legacy portal definitions**
+- old portal entries with only `id`, `name`, `description`, `status`, and `destination`
+  should be upgraded in place
+- preserve visual fields like `color`, `position`, and `rotation`
+- add the new metadata fields so the same registry can drive future atlas, status wall,
+  preview cards, and many-portal navigation without inventing parallel registries
+
 ## Portal: Bannerlord (Primary)
 
 **Steam App ID:** `261550`

LEGACY_MATRIX_AUDIT.md

@@ -0,0 +1,141 @@
+# Legacy Matrix Audit
+
+Purpose:
+Preserve useful work from `/Users/apayne/the-matrix` before the Nexus browser shell is rebuilt.
+
+Canonical rule:
+- `Timmy_Foundation/the-nexus` is the only canonical 3D repo.
+- `/Users/apayne/the-matrix` is legacy source material, not a parallel product.
+
+## Verified Legacy Matrix State
+
+Local legacy repo:
+- `/Users/apayne/the-matrix`
+
+Observed facts:
+- Vite browser app exists
+- `npm test` passes with `87 passed, 0 failed`
+- 23 JS modules under `js/`
+- package scripts include `dev`, `build`, `preview`, and `test`
+
+## Known historical Nexus snapshot
+
+Useful in-repo reference point:
+- `0518a1c3ae3c1d0afeb24dea9772102f5a3d9a66`
+
+That snapshot still contains browser-world root files such as:
+- `index.html`
+- `app.js`
+- `style.css`
+- `package.json`
+- `tests/`
+
+## Rescue Candidates
+
+### Carry forward into Nexus vNext
+
+1. `agent-defs.js`
+- agent identity definitions
+- useful as seed data/model for visible entities in the world
+
+2. `agents.js`
+- agent objects, state machine, connection lines
+- useful for visualizing Timmy / subagents / system processes in a world-native way
+
+3. `avatar.js`
+- visitor embodiment, movement, camera handling
+- strongly aligned with "training ground" and "walk the world" goals
+
+4. `ui.js`
+- HUD, chat surfaces, overlays
+- useful if rebuilt against real harness data instead of stale fake state
+
+5. `websocket.js`
+- browser-side live bridge patterns
+- useful if retethered to Hermes-facing transport
+
+6. `transcript.js`
+- local transcript capture pattern
+- useful if durable truth still routes through Hermes and browser cache remains secondary
+
+7. `ambient.js`
+- mood / atmosphere system
+- directly supports wizardly presentation without changing system authority
+
+8. `satflow.js`
+- visual economy / payment flow motifs
+- useful if Timmy's economy/agent interactions become a real visible layer
+
+9. `economy.js`
+- treasury / wallet panel ideas
+- useful if later backed by real sovereign metrics
+
+10. `presence.js`
+- who-is-here / online-state UI
+- useful for showing human + agent + process presence in the world
+
+11. `interaction.js`
+- clicking, inspecting, selecting world entities
+- likely needed in any real browser-facing Nexus shell
+
+12. `quality.js`
+- hardware-aware quality tiering
+- useful for local-first graceful degradation on Mac hardware
+
+13. `bark.js`
+- prominent speech / bark system
+- strong fit for Timmy's expressive presence in-world
+
+14. `world.js`, `effects.js`, `scene-objects.js`, `zones.js`
+- broad visual foundation work
+- should be mined for patterns, not blindly transplanted
+
+15. `test/smoke.mjs`
+- browser smoke discipline
+- should inform rebuilt validation in canonical Nexus repo
+
+### Archive as reference, not direct carry-forward
+
+- demo/autopilot assumptions that pretend fake backend activity is real
+- any websocket schema that no longer matches Hermes truth
+- Vite-specific plumbing that is only useful if we consciously recommit to Vite
+
+### Deliberately drop unless re-justified
+
+- anything that presents mock data as if it were live
+- anything that duplicates a better Hermes-native telemetry path
+- anything that turns the browser into the system of record
+
+## Concern Separation for Nexus vNext
+
+When rebuilding inside `the-nexus`, keep concerns separated:
+
+1. World shell / rendering
+- scene, camera, movement, atmosphere
+
+2. Presence and embodiment
+- avatar, agent placement, selection, bark/chat surfaces
+
+3. Harness bridge
+- websocket / API bridge from Hermes truth into browser state
+
+4. Visualization panels
+- metrics, presence, economy, portal states, transcripts
+
+5. Validation
+- smoke tests, screenshot proof, provenance checks
+
+6. Game portal layer
+- Morrowind / portal-specific interaction surfaces
+
+Do not collapse all of this into one giant app file again.
+Do not let visual shell code become telemetry authority.
+
+## Migration Rule
+
+Rescue knowledge first.
+Then rescue modules.
+Then rebuild the browser shell inside `the-nexus`.
+
+No more ghost worlds.
+No more parallel 3D repos.

README.md

@@ -1,70 +1,101 @@
 # ◈ The Nexus — Timmy's Sovereign Home
 
-A Three.js environment serving as Timmy's sovereign space — like Dr. Strange's Sanctum Sanctorum, existing outside time. The Nexus is the central hub from which all worlds are accessed through portals.
+The Nexus is Timmy's canonical 3D/home-world repo.
 
-## Features
+It is meant to become two things at once:
+- a local-first training ground for Timmy
+- a wizardly visualization surface for the living system
 
-- **Procedural Nebula Skybox** — animated stars, twinkling, layered nebula clouds
-- **Batcave Terminal** — 5 holographic display panels arranged in an arc showing:
-  - Nexus Command (system status, harness state, agent loops)
-  - Dev Queue (live Gitea issue references)
-  - Metrics (uptime, commits, CPU/MEM)
-  - Thought Stream (Timmy's current thoughts)
-  - Agent Status (all agent states)
-- **Morrowind Portal** — glowing torus with animated swirl shader, ready for world connection
-- **Admin Chat (Timmy Terminal)** — real-time message interface, ready for Hermes WebSocket
-- **Nexus Core** — floating crystalline icosahedron on pedestal
-- **Ambient Environment** — crystal formations, floating runestones, energy particles, atmospheric fog
-- **WASD + Mouse Navigation** — first-person exploration of the space
-- **Post-Processing** — Unreal Bloom + SMAA antialiasing
+## Current Truth
 
-## Architecture
+As of current `main`, this repo does **not** ship a browser 3D world.
+In plain language: current `main` does not ship a browser 3D world.
 
-```
-the-nexus/
-├── index.html    # Entry point with HUD overlay, chat panel, loading screen
-├── style.css     # Nexus design system (dark space theme, holographic panels)
-└── app.js        # Three.js scene, shaders, controls, game loop
-```
+A clean checkout of `Timmy_Foundation/the-nexus` on `main` currently contains:
+- Python heartbeat / cognition files under `nexus/`
+- `server.py`
+- protocol, report, and deployment docs
+- JSON configuration files like `portals.json` and `vision.json`
+
+It does **not** currently contain an active root frontend such as:
+- `index.html`
+- `app.js`
+- `style.css`
+- `package.json`
+
+Serving the repo root today shows a directory listing, not a rendered world.
+
+## One Canonical 3D Repo
+
+`Timmy_Foundation/the-nexus` is the only canonical 3D repo.
+In plain language: Timmy_Foundation/the-nexus is the only canonical 3D repo.
+
+The old local browser app at:
+- `/Users/apayne/the-matrix`
+
+is legacy source material, not a second repo to keep evolving in parallel.
+Useful work from it must be audited and migrated here.
+
+See:
+- `LEGACY_MATRIX_AUDIT.md`
+
+## Why this matters
+
+We do not want to lose real quality work.
+We also do not want to keep two drifting 3D repos alive by accident.
+
+The rule is:
+- rescue good work from legacy Matrix
+- rebuild inside `the-nexus`
+- keep telemetry and durable truth flowing through the Hermes harness
+- keep OpenClaw as a sidecar, not the authority
+
+## Verified historical browser-world snapshot
+
+The commit the user pointed at:
+- `0518a1c3ae3c1d0afeb24dea9772102f5a3d9a66`
+
+still contains the old root browser files (`index.html`, `app.js`, `style.css`, `package.json`, tests/), so it is a useful in-repo reference point for what existed before the later deletions.
+
+## Active migration backlog
+
+- `#684` sync docs to repo truth
+- `#685` preserve legacy Matrix quality work before rewrite
+- `#686` rebuild browser smoke / visual validation for the real Nexus repo
+- `#687` restore a wizardly local-first visual shell from audited Matrix components
+- `#672` rebuild the portal stack as Timmy → Reflex → Pilot
+- `#673` deterministic Morrowind pilot loop with world-state proof
+- `#674` reflex tactical layer and semantic trajectory logging
+- `#675` deterministic context compaction for long local sessions
+
+## What gets preserved from legacy Matrix
+
+High-value candidates include:
+- visitor movement / embodiment
+- chat, bark, and presence systems
+- transcript logging
+- ambient / visual atmosphere systems
+- economy / satflow visualizations
+- smoke and browser validation discipline
+
+Those pieces should be carried forward only if they serve the mission and are re-tethered to real local system state.
 
 ## Running Locally
 
-```bash
-npx serve . -l 3000
-# Open http://localhost:3000
-```
+### Current repo truth
 
-## Roadmap
+There is no root browser app on current `main`.
+Do not tell people to static-serve the repo root and expect a world.
 
-- [ ] Wire chat to Hermes WebSocket (`/api/world/ws`)
-- [ ] Pull live data into terminal panels from Timmy's actual state
-- [ ] Portal walk-through interaction to load destination worlds
-- [ ] Timmy's avatar (lizard wizard body he designs himself)
-- [ ] Connect to AlexanderWhitestone.com as public entry point
-- [ ] Integrate existing Replit timmy-tower world code
+### What you can run now
 
-## Related
+- `python3 server.py` for the local websocket bridge
+- Python modules under `nexus/` for heartbeat / cognition work
 
-- **Gitea Issue**: [#1090 — EPIC: Nexus v1](http://143.198.27.163:3000/rockachopa/Timmy-time-dashboard/issues/1090)
-- **Live Demo**: Deployed via Perplexity Computer
+### Browser world restoration path
 
-## Groq Worker
-
-The Groq worker is a dedicated worker for the Groq API. It is designed to be used by the Nexus Mind to offload the thinking process to the Groq API.
-
-### Usage
-
-To use the Groq worker, you need to set the `GROQ_API_KEY` environment variable. You can then run the `nexus_think.py` script with the `--groq-model` argument:
-
-```bash
-export GROQ_API_KEY="your-api-key"
-python -m nexus.nexus_think --groq-model "groq/llama3-8b-8192"
-```
-
-### Recommendations
-
-Groq has fast inference, which makes it a good candidate for tasks like PR reviews. You can use the Groq worker to review PRs by a Gitea webhook.
+The browser-facing Nexus must be rebuilt deliberately through the migration backlog above, using audited Matrix components and truthful validation.
 
 ---
 
-*Part of [The Timmy Foundation](http://143.198.27.163:3000/Timmy_Foundation)*
+*One 3D repo. One migration path. No more ghost worlds.*

nexus/__init__.py

@@ -14,7 +14,11 @@ from nexus.perception_adapter import (
 )
 from nexus.experience_store import ExperienceStore
 from nexus.trajectory_logger import TrajectoryLogger
-from nexus.nexus_think import NexusMind
+
+try:
+    from nexus.nexus_think import NexusMind
+except Exception:
+    NexusMind = None
 
 __all__ = [
     "ws_to_perception",

nexus/evennia_event_adapter.py

@@ -0,0 +1,66 @@
+"""Thin Evennia -> Nexus event normalization helpers."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def _ts(value: str | None = None) -> str:
+    return value or datetime.now(timezone.utc).isoformat()
+
+
+def session_bound(hermes_session_id: str, evennia_account: str = "Timmy", evennia_character: str = "Timmy", timestamp: str | None = None) -> dict:
+    return {
+        "type": "evennia.session_bound",
+        "hermes_session_id": hermes_session_id,
+        "evennia_account": evennia_account,
+        "evennia_character": evennia_character,
+        "timestamp": _ts(timestamp),
+    }
+
+
+def actor_located(actor_id: str, room_key: str, room_name: str | None = None, timestamp: str | None = None) -> dict:
+    return {
+        "type": "evennia.actor_located",
+        "actor_id": actor_id,
+        "room_id": room_key,
+        "room_key": room_key,
+        "room_name": room_name or room_key,
+        "timestamp": _ts(timestamp),
+    }
+
+
+def room_snapshot(room_key: str, title: str, desc: str, exits: list[dict] | None = None, objects: list[dict] | None = None, occupants: list[dict] | None = None, timestamp: str | None = None) -> dict:
+    return {
+        "type": "evennia.room_snapshot",
+        "room_id": room_key,
+        "room_key": room_key,
+        "title": title,
+        "desc": desc,
+        "exits": exits or [],
+        "objects": objects or [],
+        "occupants": occupants or [],
+        "timestamp": _ts(timestamp),
+    }
+
+
+def command_issued(hermes_session_id: str, actor_id: str, command_text: str, timestamp: str | None = None) -> dict:
+    return {
+        "type": "evennia.command_issued",
+        "hermes_session_id": hermes_session_id,
+        "actor_id": actor_id,
+        "command_text": command_text,
+        "timestamp": _ts(timestamp),
+    }
+
+
+def command_result(hermes_session_id: str, actor_id: str, command_text: str, output_text: str, success: bool = True, timestamp: str | None = None) -> dict:
+    return {
+        "type": "evennia.command_result",
+        "hermes_session_id": hermes_session_id,
+        "actor_id": actor_id,
+        "command_text": command_text,
+        "output_text": output_text,
+        "success": success,
+        "timestamp": _ts(timestamp),
+    }

nexus/evennia_ws_bridge.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Publish Evennia telemetry logs into the Nexus websocket bridge."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import re
+from pathlib import Path
+from typing import Iterable
+
+import websockets
+
+from nexus.evennia_event_adapter import actor_located, command_issued, command_result, room_snapshot, session_bound
+
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+
+
+def strip_ansi(text: str) -> str:
+    return ANSI_RE.sub("", text or "")
+
+
+def clean_lines(text: str) -> list[str]:
+    text = strip_ansi(text).replace("\r", "")
+    return [line.strip() for line in text.split("\n") if line.strip()]
+
+
+def parse_room_output(text: str):
+    lines = clean_lines(text)
+    if len(lines) < 2:
+        return None
+    title = lines[0]
+    desc = lines[1]
+    exits = []
+    objects = []
+    for line in lines[2:]:
+        if line.startswith("Exits:"):
+            raw = line.split(":", 1)[1].strip()
+            raw = raw.replace(" and ", ", ")
+            exits = [{"key": token.strip(), "destination_id": token.strip().title(), "destination_key": token.strip().title()} for token in raw.split(",") if token.strip()]
+        elif line.startswith("You see:"):
+            raw = line.split(":", 1)[1].strip()
+            raw = raw.replace(" and ", ", ")
+            parts = [token.strip() for token in raw.split(",") if token.strip()]
+            objects = [{"id": p.removeprefix('a ').removeprefix('an '), "key": p.removeprefix('a ').removeprefix('an '), "short_desc": p} for p in parts]
+    return {"title": title, "desc": desc, "exits": exits, "objects": objects}
+
+
+def normalize_event(raw: dict, hermes_session_id: str) -> list[dict]:
+    out: list[dict] = []
+    event = raw.get("event")
+    actor = raw.get("actor", "Timmy")
+    timestamp = raw.get("timestamp")
+
+    if event == "connect":
+        out.append(session_bound(hermes_session_id, evennia_account=actor, evennia_character=actor, timestamp=timestamp))
+        parsed = parse_room_output(raw.get("output", ""))
+        if parsed:
+            out.append(actor_located(actor, parsed["title"], parsed["title"], timestamp=timestamp))
+            out.append(room_snapshot(parsed["title"], parsed["title"], parsed["desc"], exits=parsed["exits"], objects=parsed["objects"], timestamp=timestamp))
+        return out
+
+    if event == "command":
+        cmd = raw.get("command", "")
+        output = raw.get("output", "")
+        out.append(command_issued(hermes_session_id, actor, cmd, timestamp=timestamp))
+        success = not output.startswith("Command '") and not output.startswith("Could not find")
+        out.append(command_result(hermes_session_id, actor, cmd, strip_ansi(output), success=success, timestamp=timestamp))
+        parsed = parse_room_output(output)
+        if parsed:
+            out.append(actor_located(actor, parsed["title"], parsed["title"], timestamp=timestamp))
+            out.append(room_snapshot(parsed["title"], parsed["title"], parsed["desc"], exits=parsed["exits"], objects=parsed["objects"], timestamp=timestamp))
+        return out
+
+    return out
+
+
+async def playback(log_path: Path, ws_url: str):
+    hermes_session_id = log_path.stem
+    async with websockets.connect(ws_url) as ws:
+        for line in log_path.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            raw = json.loads(line)
+            for event in normalize_event(raw, hermes_session_id):
+                await ws.send(json.dumps(event))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Publish Evennia telemetry into the Nexus websocket bridge")
+    parser.add_argument("log_path", help="Path to Evennia telemetry JSONL")
+    parser.add_argument("--ws", default="ws://127.0.0.1:8765", help="Nexus websocket bridge URL")
+    args = parser.parse_args()
+    asyncio.run(playback(Path(args.log_path).expanduser(), args.ws))
+
+
+if __name__ == "__main__":
+    main()

nexus/perception_adapter.py

@@ -199,6 +199,56 @@ def perceive_action_result(data: dict) -> Optional[Perception]:
     )
 
 
+def perceive_evennia_actor_located(data: dict) -> Optional[Perception]:
+    actor = data.get("actor_id", "Timmy")
+    room = data.get("room_name") or data.get("room_key") or data.get("room_id")
+    if not room:
+        return None
+    return Perception(
+        timestamp=time.time(),
+        raw_type="evennia.actor_located",
+        description=f"{actor} is now in {room}.",
+        salience=0.7,
+    )
+
+
+def perceive_evennia_room_snapshot(data: dict) -> Optional[Perception]:
+    title = data.get("title") or data.get("room_key") or data.get("room_id")
+    desc = data.get("desc", "")
+    exits = ", ".join(exit.get("key", "") for exit in data.get("exits", []) if exit.get("key"))
+    objects = ", ".join(obj.get("key", "") for obj in data.get("objects", []) if obj.get("key"))
+    if not title:
+        return None
+    parts = [f"You are in {title}."]
+    if desc:
+        parts.append(desc)
+    if exits:
+        parts.append(f"Exits: {exits}.")
+    if objects:
+        parts.append(f"You see: {objects}.")
+    return Perception(
+        timestamp=time.time(),
+        raw_type="evennia.room_snapshot",
+        description=" ".join(parts),
+        salience=0.85,
+    )
+
+
+def perceive_evennia_command_result(data: dict) -> Optional[Perception]:
+    success = data.get("success", True)
+    command = data.get("command_text", "your command")
+    output = data.get("output_text", "")
+    desc = f"Your world command {'succeeded' if success else 'failed'}: {command}."
+    if output:
+        desc += f" {output[:240]}"
+    return Perception(
+        timestamp=time.time(),
+        raw_type="evennia.command_result",
+        description=desc,
+        salience=0.8,
+    )
+
+
 # Registry of WS type → perception function
 PERCEPTION_MAP = {
     "agent_state":      perceive_agent_state,
@@ -212,6 +262,9 @@ PERCEPTION_MAP = {
     "action_result":    perceive_action_result,
     "heartbeat":        lambda _: None,  # Ignore
     "dual_brain":       lambda _: None,  # Internal — not part of sensorium
+    "evennia.actor_located": perceive_evennia_actor_located,
+    "evennia.room_snapshot": perceive_evennia_room_snapshot,
+    "evennia.command_result": perceive_evennia_command_result,
 }
 
 

portals.json

@@ -4,12 +4,20 @@
     "name": "Morrowind",
     "description": "The Vvardenfell harness. Ash storms and ancient mysteries.",
     "status": "online",
+    "portal_type": "game-world",
+    "world_category": "rpg",
+    "environment": "production",
+    "access_mode": "public",
+    "readiness_state": "playable",
+    "telemetry_source": "hermes-harness:morrowind-mcp",
+    "owner": "Timmy",
     "color": "#ff6600",
     "position": { "x": 15, "y": 0, "z": -10 },
     "rotation": { "y": -0.5 },
     "destination": {
       "url": "https://morrowind.timmy.foundation",
       "type": "harness",
+      "action_label": "Enter Vvardenfell",
       "params": { "world": "vvardenfell" }
     }
   },
@@ -17,13 +25,21 @@
     "id": "bannerlord",
     "name": "Bannerlord",
     "description": "Calradia battle harness. Massive armies, tactical command.",
-    "status": "online",
+    "status": "rebuilding",
+    "portal_type": "game-world",
+    "world_category": "strategy-rpg",
+    "environment": "staging",
+    "access_mode": "operator",
+    "readiness_state": "prototype",
+    "telemetry_source": "hermes-harness:bannerlord-bridge",
+    "owner": "Timmy",
     "color": "#ffd700",
     "position": { "x": -15, "y": 0, "z": -10 },
     "rotation": { "y": 0.5 },
     "destination": {
       "url": "https://bannerlord.timmy.foundation",
       "type": "harness",
+      "action_label": "Enter Calradia",
       "params": { "world": "calradia" }
     }
   },
@@ -32,12 +48,20 @@
     "name": "Workshop",
     "description": "The creative harness. Build, script, and manifest.",
     "status": "online",
+    "portal_type": "operator-room",
+    "world_category": "workspace",
+    "environment": "local",
+    "access_mode": "local-only",
+    "readiness_state": "active",
+    "telemetry_source": "hermes-harness:workshop-state",
+    "owner": "Alexander",
     "color": "#4af0c0",
     "position": { "x": 0, "y": 0, "z": -20 },
     "rotation": { "y": 0 },
     "destination": {
       "url": "https://workshop.timmy.foundation",
       "type": "harness",
+      "action_label": "Enter Workshop",
       "params": { "mode": "creative" }
     }
   }

tests/test_evennia_event_adapter.py

@@ -0,0 +1,56 @@
+from nexus.evennia_event_adapter import actor_located, command_issued, command_result, room_snapshot, session_bound
+from nexus.perception_adapter import ws_to_perception
+
+
+def test_session_bound_schema():
+    event = session_bound("sess-1")
+    assert event["type"] == "evennia.session_bound"
+    assert event["hermes_session_id"] == "sess-1"
+    assert event["evennia_account"] == "Timmy"
+
+
+def test_room_snapshot_schema():
+    event = room_snapshot(
+        room_key="Chapel",
+        title="Chapel",
+        desc="Quiet room.",
+        exits=[{"key": "courtyard", "destination_id": "Courtyard", "destination_key": "Courtyard"}],
+        objects=[{"id": "Book of the Soul", "key": "Book of the Soul", "short_desc": "A doctrinal anchor."}],
+    )
+    assert event["type"] == "evennia.room_snapshot"
+    assert event["title"] == "Chapel"
+    assert event["objects"][0]["key"] == "Book of the Soul"
+
+
+def test_evennia_room_snapshot_becomes_perception():
+    perception = ws_to_perception(
+        room_snapshot(
+            room_key="Workshop",
+            title="Workshop",
+            desc="Tools everywhere.",
+            exits=[{"key": "courtyard", "destination_id": "Courtyard", "destination_key": "Courtyard"}],
+            objects=[{"id": "Workbench", "key": "Workbench", "short_desc": "A broad workbench."}],
+        )
+    )
+    assert perception is not None
+    assert "Workshop" in perception.description
+    assert "Workbench" in perception.description
+
+
+def test_evennia_command_result_becomes_perception():
+    perception = ws_to_perception(command_result("sess-2", "Timmy", "look Book of the Soul", "Book of the Soul. A doctrinal anchor.", True))
+    assert perception is not None
+    assert "succeeded" in perception.description.lower()
+    assert "Book of the Soul" in perception.description
+
+
+def test_evennia_actor_located_becomes_perception():
+    perception = ws_to_perception(actor_located("Timmy", "Gate"))
+    assert perception is not None
+    assert "Gate" in perception.description
+
+
+def test_evennia_command_issued_schema():
+    event = command_issued("sess-3", "Timmy", "chapel")
+    assert event["type"] == "evennia.command_issued"
+    assert event["command_text"] == "chapel"

tests/test_evennia_ws_bridge.py

@@ -0,0 +1,36 @@
+from nexus.evennia_ws_bridge import clean_lines, normalize_event, parse_room_output, strip_ansi
+
+
+def test_strip_ansi_removes_escape_codes():
+    assert strip_ansi('\x1b[1mGate\x1b[0m') == 'Gate'
+
+
+def test_parse_room_output_extracts_room_exits_and_objects():
+    parsed = parse_room_output('\x1b[1mChapel\x1b[0m\nQuiet room.\nExits: courtyard\nYou see: a Book of the Soul and a Prayer Wall')
+    assert parsed['title'] == 'Chapel'
+    assert parsed['exits'][0]['key'] == 'courtyard'
+    keys = [obj['key'] for obj in parsed['objects']]
+    assert 'Book of the Soul' in keys
+    assert 'Prayer Wall' in keys
+
+
+def test_normalize_connect_emits_session_and_room_events():
+    events = normalize_event({'event': 'connect', 'actor': 'Timmy', 'output': 'Gate\nA threshold.\nExits: enter'}, 'sess1')
+    types = [event['type'] for event in events]
+    assert 'evennia.session_bound' in types
+    assert 'evennia.actor_located' in types
+    assert 'evennia.room_snapshot' in types
+
+
+def test_normalize_command_emits_command_and_snapshot():
+    events = normalize_event({'event': 'command', 'actor': 'timmy', 'command': 'courtyard', 'output': 'Courtyard\nOpen court.\nExits: gate, workshop\nYou see: a Map Table'}, 'sess2')
+    types = [event['type'] for event in events]
+    assert types[0] == 'evennia.command_issued'
+    assert 'evennia.command_result' in types
+    assert 'evennia.room_snapshot' in types
+
+
+def test_normalize_failed_command_marks_failure():
+    events = normalize_event({'event': 'command', 'actor': 'timmy', 'command': 'workshop', 'output': "Command 'workshop' is not available."}, 'sess3')
+    result = [event for event in events if event['type'] == 'evennia.command_result'][0]
+    assert result['success'] is False

tests/test_portal_registry_schema.py

@@ -0,0 +1,45 @@
+import json
+from pathlib import Path
+
+
+REQUIRED_TOP_LEVEL_KEYS = {
+    "id",
+    "name",
+    "description",
+    "status",
+    "portal_type",
+    "world_category",
+    "environment",
+    "access_mode",
+    "readiness_state",
+    "telemetry_source",
+    "owner",
+    "destination",
+}
+
+REQUIRED_DESTINATION_KEYS = {"type", "action_label"}
+
+
+def test_portals_json_uses_expanded_registry_schema() -> None:
+    portals = json.loads(Path("portals.json").read_text())
+
+    assert portals, "portals.json should define at least one portal"
+    for portal in portals:
+        assert REQUIRED_TOP_LEVEL_KEYS.issubset(portal.keys())
+        assert REQUIRED_DESTINATION_KEYS.issubset(portal["destination"].keys())
+
+
+def test_gameportal_protocol_documents_new_metadata_fields_and_migration() -> None:
+    protocol = Path("GAMEPORTAL_PROTOCOL.md").read_text()
+
+    for term in [
+        "portal_type",
+        "world_category",
+        "environment",
+        "access_mode",
+        "readiness_state",
+        "telemetry_source",
+        "owner",
+        "Migration from legacy portal definitions",
+    ]:
+        assert term in protocol

tests/test_repo_truth.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+
+def test_readme_states_repo_truth_and_single_canonical_3d_repo() -> None:
+    readme = Path("README.md").read_text()
+
+    assert "current `main` does not ship a browser 3D world" in readme
+    assert "Timmy_Foundation/the-nexus is the only canonical 3D repo" in readme
+    assert "/Users/apayne/the-matrix" in readme
+    assert "npx serve . -l 3000" not in readme
+
+
+def test_claude_doc_matches_current_repo_truth() -> None:
+    claude = Path("CLAUDE.md").read_text()
+
+    assert "Do not describe this repo as a live browser app on `main`." in claude
+    assert "Timmy_Foundation/the-nexus is the only canonical 3D repo." in claude
+    assert "LEGACY_MATRIX_AUDIT.md" in claude
+
+
+def test_legacy_matrix_audit_exists_and_names_rescue_targets() -> None:
+    audit = Path("LEGACY_MATRIX_AUDIT.md").read_text()
+
+    for term in [
+        "agent-defs.js",
+        "agents.js",
+        "avatar.js",
+        "ui.js",
+        "websocket.js",
+        "transcript.js",
+        "ambient.js",
+        "satflow.js",
+        "economy.js",
+    ]:
+        assert term in audit