feat: Bezalel Evennia world builder (#536)

Template and analyzer for the Codebase Genome batch (issues #667-683).

templates/GENOME-template.md:
  Reusable template with placeholders for repo name, overview,
  architecture, entry points, data flow, abstractions, API surface,
  test coverage, security, and design decisions.

scripts/genome_analyzer.py:
  Auto-generates GENOME.md skeleton from a codebase scan:
  - File counts by extension
  - Directory structure (depth 2)
  - Entry point detection (main.py, scripts/, Makefile, etc.)
  - Test file enumeration
  - README first-paragraph extraction

Usage:
  python3 scripts/genome_analyzer.py /path/to/repo --output GENOME.md
  python3 scripts/genome_analyzer.py /path/to/repo --dry-run

GENOME.md

@@ -1,209 +1,141 @@
-# GENOME.md — the-nexus
+# GENOME.md — Timmy_Foundation/timmy-home
+
+Generated by `pipelines/codebase_genome.py`.
 
 ## Project Overview
 
-`the-nexus` is a hybrid repo that combines three layers in one codebase:
+Timmy Foundation's home repository for development operations and configurations.
 
-1. A browser-facing world shell rooted in `index.html`, `boot.js`, `bootstrap.mjs`, `app.js`, `style.css`, `portals.json`, `vision.json`, `manifest.json`, and `gofai_worker.js`
-2. A Python realtime bridge centered on `server.py` plus harness code under `nexus/`
-3. A memory / fleet / operator layer spanning `mempalace/`, `mcp_servers/`, `multi_user_bridge.py`, and supporting scripts
+- Text files indexed: 3004
+- Source and script files: 186
+- Test files: 28
+- Documentation files: 701
 
-The repo is not a clean single-purpose frontend and not just a backend harness. It is a mixed world/runtime/ops repository where browser rendering, WebSocket telemetry, MCP-driven game harnesses, and fleet memory tooling coexist.
-
-Grounded repo facts from this checkout:
-- Browser shell files exist at repo root: `index.html`, `app.js`, `style.css`, `manifest.json`, `gofai_worker.js`
-- Data/config files also live at repo root: `portals.json`, `vision.json`
-- Realtime bridge exists in `server.py`
-- Game harnesses exist in `nexus/morrowind_harness.py` and `nexus/bannerlord_harness.py`
-- Memory/fleet sync exists in `mempalace/tunnel_sync.py`
-- Desktop/game automation MCP servers exist in `mcp_servers/desktop_control_server.py` and `mcp_servers/steam_info_server.py`
-- Validation exists in `tests/test_browser_smoke.py`, `tests/test_portals_json.py`, `tests/test_index_html_integrity.py`, and `tests/test_repo_truth.py`
-
-The current architecture is best understood as a sovereign world shell plus operator/game harness backend, with accumulated documentation drift from multiple restoration and migration efforts.
-
-## Architecture Diagram
+## Architecture
 
 ```mermaid
 graph TD
-    browser[Index HTML Shell\nindex.html -> boot.js -> bootstrap.mjs -> app.js]
-    assets[Root Assets\nstyle.css\nmanifest.json\ngofai_worker.js]
-    data[World Data\nportals.json\nvision.json]
-    ws[Realtime Bridge\nserver.py\nWebSocket broadcast hub]
-    gofai[In-browser GOFAI\nSymbolicEngine\nNeuroSymbolicBridge\nsetupGOFAI/updateGOFAI]
-    harnesses[Python Harnesses\nnexus/morrowind_harness.py\nnexus/bannerlord_harness.py]
-    mcp[MCP Adapters\nmcp_servers/desktop_control_server.py\nmcp_servers/steam_info_server.py]
-    memory[Memory + Fleet\nmempalace/tunnel_sync.py\nmempalace.js]
-    bridge[Operator / MUD Bridge\nmulti_user_bridge.py\ncommands/timmy_commands.py]
-    tests[Verification\ntests/test_browser_smoke.py\ntests/test_portals_json.py\ntests/test_repo_truth.py]
-    docs[Contracts + Drift Docs\nBROWSER_CONTRACT.md\nREADME.md\nCLAUDE.md\nINVESTIGATION_ISSUE_1145.md]
-
-    browser --> assets
-    browser --> data
-    browser --> gofai
-    browser --> ws
-    harnesses --> mcp
-    harnesses --> ws
-    bridge --> ws
-    memory --> ws
-    tests --> browser
-    tests --> data
-    tests --> docs
-    docs --> browser
+  repo_root["repo"]
+  angband["angband"]
+  briefings["briefings"]
+  config["config"]
+  conftest["conftest"]
+  evennia["evennia"]
+  evennia_tools["evennia_tools"]
+  evolution["evolution"]
+  gemini_fallback_setup["gemini-fallback-setup"]
+  heartbeat["heartbeat"]
+  infrastructure["infrastructure"]
+  repo_root --> angband
+  repo_root --> briefings
+  repo_root --> config
+  repo_root --> conftest
+  repo_root --> evennia
+  repo_root --> evennia_tools
 ```
 
-## Entry Points and Data Flow
+## Entry Points
 
-### Primary entry points
+- `gemini-fallback-setup.sh` — operational script (`bash gemini-fallback-setup.sh`)
+- `morrowind/hud.sh` — operational script (`bash morrowind/hud.sh`)
+- `pipelines/codebase_genome.py` — python main guard (`python3 pipelines/codebase_genome.py`)
+- `scripts/auto_restart_agent.sh` — operational script (`bash scripts/auto_restart_agent.sh`)
+- `scripts/backup_pipeline.sh` — operational script (`bash scripts/backup_pipeline.sh`)
+- `scripts/big_brain_manager.py` — operational script (`python3 scripts/big_brain_manager.py`)
+- `scripts/big_brain_repo_audit.py` — operational script (`python3 scripts/big_brain_repo_audit.py`)
+- `scripts/codebase_genome_nightly.py` — operational script (`python3 scripts/codebase_genome_nightly.py`)
+- `scripts/detect_secrets.py` — operational script (`python3 scripts/detect_secrets.py`)
+- `scripts/dynamic_dispatch_optimizer.py` — operational script (`python3 scripts/dynamic_dispatch_optimizer.py`)
+- `scripts/emacs-fleet-bridge.py` — operational script (`python3 scripts/emacs-fleet-bridge.py`)
+- `scripts/emacs-fleet-poll.sh` — operational script (`bash scripts/emacs-fleet-poll.sh`)
 
-- `index.html` — root browser entry point
-- `boot.js` — startup selector; `tests/boot.test.js` shows it chooses file-mode vs HTTP/module-mode and injects `bootstrap.mjs` when served over HTTP
-- `bootstrap.mjs` — module bootstrap for the browser shell
-- `app.js` — main browser runtime; owns world state, GOFAI wiring, metrics polling, and portal/UI logic
-- `server.py` — WebSocket broadcast bridge on `ws://0.0.0.0:8765`
-- `nexus/morrowind_harness.py` — GamePortal/MCP harness for OpenMW Morrowind
-- `nexus/bannerlord_harness.py` — GamePortal/MCP harness for Bannerlord
-- `mempalace/tunnel_sync.py` — pulls remote fleet closets into the local palace over HTTP
-- `multi_user_bridge.py` — HTTP bridge for multi-user chat/session integration
-- `mcp_servers/desktop_control_server.py` — stdio MCP server exposing screenshots/mouse/keyboard control
+## Data Flow
 
-### Data flow
-
-1. Browser startup begins at `index.html`
-2. `boot.js` decides whether the page is being served correctly; in HTTP mode it injects `bootstrap.mjs`
-3. `bootstrap.mjs` hands off to `app.js`
-4. `app.js` loads world configuration from `portals.json` and `vision.json`
-5. `app.js` constructs the Three.js scene and in-browser reasoning components, including `SymbolicEngine`, `NeuroSymbolicBridge`, `setupGOFAI()`, and `updateGOFAI()`
-6. Browser state and external runtimes connect through `server.py`, which broadcasts messages between connected clients
-7. Python harnesses (`nexus/morrowind_harness.py`, `nexus/bannerlord_harness.py`) spawn MCP subprocesses for desktop control / Steam metadata, capture state, execute actions, and feed telemetry into the Nexus bridge
-8. Memory/fleet tools like `mempalace/tunnel_sync.py` import remote palace data into local closets, extending what the operator/runtime layers can inspect
-9. Tests validate both the static browser contract and the higher-level repo-truth/memory contracts
-
-### Important repo-specific runtime facts
-
-- `portals.json` is a JSON array of portal/world/operator entries; examples in this checkout include `morrowind`, `bannerlord`, `workshop`, `archive`, `chapel`, and `courtyard`
-- `server.py` is a plain broadcast hub: clients send messages, the server forwards them to other connected clients
-- `nexus/morrowind_harness.py` and `nexus/bannerlord_harness.py` both implement a GamePortal pattern with MCP subprocess clients over stdio and WebSocket telemetry uplink
-- `mempalace/tunnel_sync.py` is not speculative; it is a real client that discovers remote wings, searches remote rooms, and writes `.closet.json` payloads locally
+1. Operators enter through `gemini-fallback-setup.sh`, `morrowind/hud.sh`, `pipelines/codebase_genome.py`.
+2. Core logic fans into top-level components: `angband`, `briefings`, `config`, `conftest`, `evennia`, `evennia_tools`.
+3. Validation is incomplete around `wizards/allegro/home/skills/red-teaming/godmode/scripts/auto_jailbreak.py`, `timmy-local/cache/agent_cache.py`, `wizards/allegro/home/skills/red-teaming/godmode/scripts/parseltongue.py`, so changes there carry regression risk.
+4. Final artifacts land as repository files, docs, or runtime side effects depending on the selected entry point.
 
 ## Key Abstractions
 
-### Browser runtime
-
-- `app.js`
-  - Defines in-browser reasoning/state machinery, including `class SymbolicEngine`, `class NeuroSymbolicBridge`, `setupGOFAI()`, and `updateGOFAI()`
-  - Couples rendering, local symbolic reasoning, metrics polling, and portal/UI logic in one very large root module
-- `BROWSER_CONTRACT.md`
-  - Acts like an executable architecture contract for the browser surface
-  - Declares required files, DOM IDs, Three.js expectations, provenance rules, and WebSocket expectations
-
-### Realtime bridge
-
-- `server.py`
-  - Single hub abstraction: a WebSocket broadcast server maintaining a `clients` set and forwarding messages from one client to the others
-  - This is the seam between browser shell, harnesses, and external telemetry producers
-
-### GamePortal harness layer
-
-- `nexus/morrowind_harness.py`
-- `nexus/bannerlord_harness.py`
-  - Both define MCP client wrappers, `GameState` / `ActionResult`-style data classes, and an Observe-Decide-Act telemetry loop
-  - The harnesses are symmetric enough to be understood as reusable portal adapters with game-specific context injected on top
-
-### Memory / fleet layer
-
-- `mempalace/tunnel_sync.py`
-  - Encodes the fleet-memory sync client contract: discover wings, pull broad room queries, write closet files, support dry-run
-- `mempalace.js`
-  - Minimal browser/Electron bridge to MemPalace commands via `window.electronAPI.execPython(...)`
-  - Important because it shows a second memory integration surface distinct from the Python fleet sync path
-
-### Operator / interaction bridge
-
-- `multi_user_bridge.py`
-- `commands/timmy_commands.py`
-  - These bridge user-facing conversations or MUD/Evennia interactions back into Timmy/Nexus services
+- `evennia/timmy_world/game.py` — classes `World`:91, `ActionSystem`:421, `TimmyAI`:539, `NPCAI`:550; functions `get_narrative_phase()`:55, `get_phase_transition_event()`:65
+- `evennia/timmy_world/world/game.py` — classes `World`:19, `ActionSystem`:326, `TimmyAI`:444, `NPCAI`:455; functions none detected
+- `timmy-world/game.py` — classes `World`:19, `ActionSystem`:349, `TimmyAI`:467, `NPCAI`:478; functions none detected
+- `wizards/allegro/home/skills/red-teaming/godmode/scripts/auto_jailbreak.py` — classes none detected; functions none detected
+- `uniwizard/self_grader.py` — classes `SessionGrade`:23, `WeeklyReport`:55, `SelfGrader`:74; functions `main()`:713
+- `uni-wizard/v3/intelligence_engine.py` — classes `ExecutionPattern`:27, `ModelPerformance`:44, `AdaptationEvent`:58, `PatternDatabase`:69; functions none detected
+- `scripts/know_thy_father/crossref_audit.py` — classes `ThemeCategory`:30, `Principle`:160, `MeaningKernel`:169, `CrossRefFinding`:178; functions `extract_themes_from_text()`:192, `parse_soul_md()`:206, `parse_kernels()`:264, `cross_reference()`:296, `generate_report()`:440, `main()`:561
+- `timmy-local/cache/agent_cache.py` — classes `CacheStats`:28, `LRUCache`:52, `ResponseCache`:94, `ToolCache`:205; functions none detected
 
 ## API Surface
 
-### Browser / static surface
+- CLI: `bash gemini-fallback-setup.sh` — operational script (`gemini-fallback-setup.sh`)
+- CLI: `bash morrowind/hud.sh` — operational script (`morrowind/hud.sh`)
+- CLI: `python3 pipelines/codebase_genome.py` — python main guard (`pipelines/codebase_genome.py`)
+- CLI: `bash scripts/auto_restart_agent.sh` — operational script (`scripts/auto_restart_agent.sh`)
+- CLI: `bash scripts/backup_pipeline.sh` — operational script (`scripts/backup_pipeline.sh`)
+- CLI: `python3 scripts/big_brain_manager.py` — operational script (`scripts/big_brain_manager.py`)
+- CLI: `python3 scripts/big_brain_repo_audit.py` — operational script (`scripts/big_brain_repo_audit.py`)
+- CLI: `python3 scripts/codebase_genome_nightly.py` — operational script (`scripts/codebase_genome_nightly.py`)
+- Python: `get_narrative_phase()` from `evennia/timmy_world/game.py:55`
+- Python: `get_phase_transition_event()` from `evennia/timmy_world/game.py:65`
+- Python: `main()` from `uniwizard/self_grader.py:713`
 
-- `index.html` served over HTTP
-- `boot.js` exports `bootPage()`; verified by `node --test tests/boot.test.js`
-- Data APIs are file-based inside the repo: `portals.json`, `vision.json`, `manifest.json`
+## Test Coverage Report
 
-### Network/runtime surface
+- Source and script files inspected: 186
+- Test files inspected: 28
+- Coverage gaps:
+  - `wizards/allegro/home/skills/red-teaming/godmode/scripts/auto_jailbreak.py` — no matching test reference detected
+  - `timmy-local/cache/agent_cache.py` — no matching test reference detected
+  - `wizards/allegro/home/skills/red-teaming/godmode/scripts/parseltongue.py` — no matching test reference detected
+  - `twitter-archive/multimodal_pipeline.py` — no matching test reference detected
+  - `wizards/allegro/home/skills/red-teaming/godmode/scripts/godmode_race.py` — no matching test reference detected
+  - `skills/productivity/google-workspace/scripts/google_api.py` — no matching test reference detected
+  - `wizards/allegro/home/skills/productivity/google-workspace/scripts/google_api.py` — no matching test reference detected
+  - `morrowind/pilot.py` — no matching test reference detected
+  - `morrowind/mcp_server.py` — no matching test reference detected
+  - `skills/research/domain-intel/scripts/domain_intel.py` — no matching test reference detected
+  - `wizards/allegro/home/skills/research/domain-intel/scripts/domain_intel.py` — no matching test reference detected
+  - `timmy-local/scripts/ingest.py` — no matching test reference detected
 
-- `python3 server.py`
-  - Starts the WebSocket bridge on port `8765`
-- `python3 l402_server.py`
-  - Local HTTP microservice for cost-estimate style responses
-- `python3 multi_user_bridge.py`
-  - Multi-user HTTP/chat bridge
+## Security Audit Findings
 
-### Harness / operator CLI surfaces
+- [medium] `briefings/briefing_20260325.json:37` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `"gitea_error": "Gitea 404: {\"errors\":null,\"message\":\"not found\",\"url\":\"http://143.198.27.163:3000/api/swagger\"}\n [http://143.198.27.163:3000/api/v1/repos/Timmy_Foundation/sovereign-orchestration/issues?state=open&type=issues&sort=created&direction=desc&limit=1&page=1]",`
+- [medium] `briefings/briefing_20260328.json:11` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `"provider_base_url": "http://localhost:8081/v1",`
+- [medium] `briefings/briefing_20260329.json:11` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `"provider_base_url": "http://localhost:8081/v1",`
+- [medium] `config.yaml:37` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `summary_base_url: http://localhost:11434/v1`
+- [medium] `config.yaml:47` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: 'http://localhost:11434/v1'`
+- [medium] `config.yaml:52` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: 'http://localhost:11434/v1'`
+- [medium] `config.yaml:57` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: 'http://localhost:11434/v1'`
+- [medium] `config.yaml:62` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: 'http://localhost:11434/v1'`
+- [medium] `config.yaml:67` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: 'http://localhost:11434/v1'`
+- [medium] `config.yaml:77` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: 'http://localhost:11434/v1'`
+- [medium] `config.yaml:82` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: 'http://localhost:11434/v1'`
+- [medium] `config.yaml:174` — hardcoded http endpoint: plaintext or fixed HTTP endpoints can drift or leak across environments. Evidence: `base_url: http://localhost:11434/v1`
 
-- `python3 nexus/morrowind_harness.py`
-- `python3 nexus/bannerlord_harness.py`
-- `python3 mempalace/tunnel_sync.py --peer <url> [--dry-run] [--n N]`
-- `python3 mcp_servers/desktop_control_server.py`
-- `python3 mcp_servers/steam_info_server.py`
+## Dead Code Candidates
 
-### Validation surface
+- `wizards/allegro/home/skills/red-teaming/godmode/scripts/auto_jailbreak.py` — not imported by indexed Python modules and not referenced by tests
+- `timmy-local/cache/agent_cache.py` — not imported by indexed Python modules and not referenced by tests
+- `wizards/allegro/home/skills/red-teaming/godmode/scripts/parseltongue.py` — not imported by indexed Python modules and not referenced by tests
+- `twitter-archive/multimodal_pipeline.py` — not imported by indexed Python modules and not referenced by tests
+- `wizards/allegro/home/skills/red-teaming/godmode/scripts/godmode_race.py` — not imported by indexed Python modules and not referenced by tests
+- `skills/productivity/google-workspace/scripts/google_api.py` — not imported by indexed Python modules and not referenced by tests
+- `wizards/allegro/home/skills/productivity/google-workspace/scripts/google_api.py` — not imported by indexed Python modules and not referenced by tests
+- `morrowind/pilot.py` — not imported by indexed Python modules and not referenced by tests
+- `morrowind/mcp_server.py` — not imported by indexed Python modules and not referenced by tests
+- `skills/research/domain-intel/scripts/domain_intel.py` — not imported by indexed Python modules and not referenced by tests
 
-- `python3 -m pytest tests/test_portals_json.py tests/test_index_html_integrity.py tests/test_repo_truth.py -q`
-- `node --test tests/boot.test.js`
-- `python3 -m py_compile server.py nexus/morrowind_harness.py nexus/bannerlord_harness.py mempalace/tunnel_sync.py mcp_servers/desktop_control_server.py`
-- `tests/test_browser_smoke.py` defines the higher-cost Playwright smoke contract for the world shell
+## Performance Bottleneck Analysis
 
-## Test Coverage Gaps
-
-Strongly covered in this checkout:
-- `tests/test_portals_json.py` validates `portals.json`
-- `tests/test_index_html_integrity.py` checks merge-marker/DOM-integrity regressions in `index.html`
-- `tests/boot.test.js` verifies `boot.js` startup behavior
-- `tests/test_repo_truth.py` validates the repo-truth documents
-- Multiple `tests/test_mempalace_*.py` files cover the palace layer
-- `tests/test_bannerlord_harness.py` exists for the Bannerlord harness
-
-Notable gaps or weak seams:
-- `nexus/morrowind_harness.py` is large and operationally critical, but the generated baseline still flags it as a gap relative to its size/complexity
-- `mcp_servers/desktop_control_server.py` exposes high-power automation but has no obvious dedicated test file in the root `tests/` suite
-- `app.js` is the dominant browser runtime file and mixes rendering, GOFAI, metrics, and integration logic in one place; browser smoke exists, but there is limited unit-level decomposition around those subsystems
-- `mempalace.js` appears minimally bridged and stale relative to the richer Python MemPalace layer
-- `multi_user_bridge.py` is a large integration surface and should be treated as high regression risk even though it is central to operator/chat flow
-
-## Security Considerations
-
-- `server.py` binds `HOST = "0.0.0.0"`, exposing the broadcast bridge beyond localhost unless network controls limit it
-- The WebSocket bridge is a broadcast hub without visible authentication in `server.py`; connected clients are trusted to send messages into the bus
-- `mcp_servers/desktop_control_server.py` exposes mouse/keyboard/screenshot control through a stdio MCP server. In any non-local or poorly isolated runtime, this is a privileged automation surface
-- `app.js` contains hardcoded local/network endpoints such as `http://localhost:${L402_PORT}/api/cost-estimate` and `http://localhost:8082/metrics`; these are convenient for local development but create environment drift and deployment assumptions
-- `app.js` also embeds explicit endpoint/status references like `ws://143.198.27.163:8765`, which is operationally brittle and the kind of hardcoded location data that drifts across environments
-- `mempalace.js` shells out through `window.electronAPI.execPython(...)`; this is powerful and useful, but it is a clear trust boundary between UI and host execution
-- `INVESTIGATION_ISSUE_1145.md` documents an earlier integrity hazard: agents writing to `public/nexus/` instead of canonical root paths. That path confusion is both an operational and security concern because it makes provenance harder to reason about
-
-## Runtime Truth and Docs Drift
-
-The most important architecture finding in this repo is not a class or subsystem. It is a truth mismatch.
-
-- README.md says current `main` does not ship a browser 3D world
-- CLAUDE.md declares root `app.js` and `index.html` as canonical frontend paths
-- tests and browser contract now assume the root frontend exists
-
-All three statements are simultaneously present in this checkout.
-
-Grounded evidence:
-- `README.md` still says the repo does not contain an active root frontend such as `index.html`, `app.js`, or `style.css`
-- the current checkout does contain `index.html`, `app.js`, `style.css`, `manifest.json`, and `gofai_worker.js`
-- `BROWSER_CONTRACT.md` explicitly treats those root files as required browser assets
-- `tests/test_browser_smoke.py` serves those exact files and validates DOM/WebGL contracts against them
-- `tests/test_index_html_integrity.py` assumes `index.html` is canonical and production-relevant
-- `CLAUDE.md` says frontend code lives at repo root and explicitly warns against `public/nexus/`
-- `INVESTIGATION_ISSUE_1145.md` explains why `public/nexus/` is a bad/corrupt duplicate path and confirms the real classical AI code lives in root `app.js`
-
-The honest conclusion:
-- The repo contains a partially restored or actively re-materialized browser surface
-- The docs are preserving an older migration truth while the runtime files and smoke contracts describe a newer present-tense truth
-- Any future work in `the-nexus` must choose one truth and align `README.md`, `CLAUDE.md`, smoke tests, and file layout around it
-
-That drift is itself a critical architectural fact and should be treated as first-order design debt, not a side note.
+- `angband/mcp_server.py` — large module (353 lines) likely hides multiple responsibilities
+- `evennia/timmy_world/game.py` — large module (1541 lines) likely hides multiple responsibilities
+- `evennia/timmy_world/world/game.py` — large module (1345 lines) likely hides multiple responsibilities
+- `morrowind/mcp_server.py` — large module (451 lines) likely hides multiple responsibilities
+- `morrowind/pilot.py` — large module (459 lines) likely hides multiple responsibilities
+- `pipelines/codebase_genome.py` — large module (557 lines) likely hides multiple responsibilities
+- `scripts/know_thy_father/crossref_audit.py` — large module (657 lines) likely hides multiple responsibilities
+- `scripts/know_thy_father/index_media.py` — large module (405 lines) likely hides multiple responsibilities
+- `scripts/know_thy_father/synthesize_kernels.py` — large module (416 lines) likely hides multiple responsibilities
+- `scripts/tower_game.py` — large module (395 lines) likely hides multiple responsibilities

evennia/timmy_world/GENOME.md

@@ -1,417 +1,242 @@
-# GENOME.md — evennia-local-world
+# GENOME.md: evennia-local-world
 
-*Generated: 2026-04-21 07:07:29 UTC | Refreshed for timmy-home #677*
+> Codebase Genome — Auto-generated analysis of the timmy_world Evennia project.
 
 ## Project Overview
 
-`evennia/timmy_world` is a hybrid codebase with two layers living side by side:
+**Name:** timmy_world
+**Framework:** Evennia 6.0 (MUD/MUSH engine)
+**Purpose:** Tower MUD world with spatial memory. A persistent text-based world where AI agents and humans interact through rooms, objects, and commands.
+**Language:** Python 3.11
+**Lines of Code:** ~40 files, ~2,500 lines
 
-1. A mostly stock Evennia 6.0 game directory:
-   - `server/conf/*.py`
-   - `typeclasses/*.py`
-   - `commands/*.py`
-   - `web/**/*.py`
-   - `world/prototypes.py`
-   - `world/help_entries.py`
-2. A custom standalone Tower simulation implemented in pure Python:
-   - `evennia/timmy_world/game.py`
-   - `evennia/timmy_world/world/game.py`
-   - `evennia/timmy_world/play_200.py`
-
-Grounded metrics from live inspection:
-- 68 tracked files under `evennia/timmy_world`
-- 43 Python files
-- 4,985 Python LOC
-- largest modules:
-  - `evennia/timmy_world/game.py` — 1,541 lines
-  - `evennia/timmy_world/world/game.py` — 1,345 lines
-  - `evennia/timmy_world/play_200.py` — 275 lines
-  - `evennia/timmy_world/typeclasses/objects.py` — 217 lines
-  - `evennia/timmy_world/commands/command.py` — 187 lines
-
-The repo is not just an Evennia shell. The distinctive product logic lives in the standalone Tower simulator. That simulator models five rooms, named agents, trust/energy systems, narrative phases, NPC decision-making, and JSON persistence. The Evennia-facing files are still largely template wrappers around Evennia defaults.
+This is a custom Evennia game world built for the Timmy Foundation fleet. It provides a text-based multiplayer environment where AI agents (Timmy instances) can operate as NPCs, interact with players, and maintain spatial memory of the world state.
 
 ## Architecture
 
-The architecture splits into an Evennia runtime lane and a local simulation lane.
-
-```mermaid
-graph TD
-    subgraph External Clients
-        Telnet[Telnet client :4000]
-        Browser[Browser / webclient :4001]
-        Operator[Local operator]
-    end
-
-    subgraph Evennia Runtime
-        Settings[server/conf/settings.py]
-        URLs[web/urls.py]
-        Cmdsets[commands/default_cmdsets.py]
-        Typeclasses[typeclasses/*.py]
-        WorldDocs[world/prototypes.py + world/help_entries.py]
-        WebHooks[server/conf/web_plugins.py]
-    end
-
-    subgraph Standalone Tower Simulator
-        Play200[play_200.py]
-        RootGame[game.py]
-        AltGame[world/game.py]
-        Engine[GameEngine / PlayerInterface / NPCAI]
-        State[game_state.json + timmy_log.md]
-    end
-
-    Telnet --> Settings
-    Browser --> URLs
-    Settings --> Cmdsets
-    Cmdsets --> Typeclasses
-    URLs --> WebHooks
-    Typeclasses --> WorldDocs
-
-    Operator --> Play200
-    Play200 --> RootGame
-    RootGame --> Engine
-    AltGame --> Engine
-    Engine --> State
+```
+timmy_world/
++-- server/
+|   +-- conf/
+|       +-- settings.py          # Server configuration
+|       +-- at_initial_setup.py  # First-run setup hook
+|       +-- at_server_startstop.py
+|       +-- inputfuncs.py        # Client input handlers
+|       +-- lockfuncs.py         # Permission lock functions
+|       +-- cmdparser.py         # Command parsing overrides
+|       +-- connection_screens.py # Login/creation screens
+|       +-- serversession.py     # Session management
+|       +-- web_plugins.py       # Web client plugins
++-- typeclasses/
+|   +-- characters.py            # Player/NPC characters
+|   +-- rooms.py                 # Room containers
+|   +-- objects.py               # Items and world objects (218 lines, key module)
+|   +-- exits.py                 # Room connectors
+|   +-- accounts.py              # Player accounts (149 lines)
+|   +-- channels.py              # Communication channels
+|   +-- scripts.py               # Persistent background scripts (104 lines)
++-- commands/
+|   +-- command.py               # Base command class (188 lines)
+|   +-- default_cmdsets.py       # Command set definitions
++-- world/
+|   +-- prototypes.py            # Object spawn templates
+|   +-- help_entries.py          # File-based help system
++-- web/
+    +-- urls.py                  # Web URL routing
+    +-- api/                     # REST API endpoints
+    +-- webclient/               # Web client interface
+    +-- website/                 # Web site views
+    +-- admin/                   # Django admin
 ```
 
-What is actually wired today:
-- `server/conf/settings.py` only overrides `SERVERNAME = "timmy_world"` and optionally imports `server.conf.secret_settings`.
-- `web/urls.py` mounts `web.website.urls`, `web.webclient.urls`, `web.admin.urls`, then appends `evennia.web.urls`.
-- `commands/default_cmdsets.py` subclasses Evennia defaults but does not add custom commands yet.
-- `typeclasses/*.py` are thin wrappers around Evennia defaults.
-- `server/conf/web_plugins.py` returns the web roots unchanged.
-- `server/conf/at_initial_setup.py` is a no-op.
-- `world/batch_cmds.ev` is still template commentary rather than a real build script.
+## Mermaid Architecture Diagram
 
-What is custom and stateful today:
-- `evennia/timmy_world/game.py`
-- `evennia/timmy_world/world/game.py`
-- `evennia/timmy_world/play_200.py`
+```mermaid
+graph TB
+    subgraph "Entry Points"
+        Telnet[Telnet:4000]
+        Web[Web Client:4001]
+        API[REST API]
+    end
 
-## Runtime Truth and Docs Drift
+    subgraph "Evennia Core"
+        Portal[Portal - Connection Handler]
+        Server[Server - Game Logic]
+    end
 
-The strongest architecture fact in this directory is the split between template Evennia scaffolding and custom simulation logic.
+    subgraph "timmy_world"
+        TC[Typeclasses]
+        CMD[Commands]
+        WORLD[World]
+        CONF[Config]
+    end
 
-Drift discovered during inspection:
-- `evennia/timmy_world/README.md` is the stock Evennia welcome text.
-- `server/conf/at_initial_setup.py` is empty, so the Evennia world is not auto-populating custom Tower content at first boot.
-- `world/batch_cmds.ev` is also a template, not a concrete room/object bootstrap file.
-- The deepest custom logic is not in the typeclasses or server hooks. It is in `evennia/timmy_world/game.py` and `evennia/timmy_world/world/game.py`.
-- `evennia/timmy_world/play_200.py` imports `from game import GameEngine, NARRATIVE_PHASES`, which proves the root `game.py` is an active entry point.
-- `evennia/timmy_world/world/game.py` is not dead weight either; it contains its own `World`, `ActionSystem`, `NPCAI`, `DialogueSystem`, `GameEngine`, and `PlayerInterface` stack.
+    subgraph "Typeclasses"
+        Char[Character]
+        Room[Room]
+        Obj[Object]
+        Exit[Exit]
+        Acct[Account]
+        Script[Script]
+    end
 
-So the current repo truth is:
-- Evennia layer = shell and integration surface
-- standalone simulation layer = where the real Tower behavior currently lives
+    subgraph "External"
+        Timmy[Timmy AI Agent]
+        Humans[Human Players]
+    end
 
-That split should be treated as a first-order design fact, not smoothed over.
+    Telnet --> Portal
+    Web --> Portal
+    API --> Server
+    Portal --> Server
+    Server --> TC
+    Server --> CMD
+    Server --> WORLD
+    Server --> CONF
+
+    Timmy -->|Telnet/Script| Portal
+    Humans -->|Telnet/Web| Portal
+
+    Char --> Room
+    Room --> Exit
+    Exit --> Room
+    Obj --> Room
+    Acct --> Char
+    Script --> Room
+```
 
 ## Entry Points
 
-### 1. Evennia server startup
-Primary operational entry point for the networked world:
+| Entry Point | Port | Protocol | Purpose |
+|-------------|------|----------|---------|
+| Telnet | 4000 | MUD protocol | Primary game connection |
+| Web Client | 4001 | HTTP/WebSocket | Browser-based play |
+| REST API | 4001 | HTTP | External integrations |
 
+**Server Start:**
 ```bash
-cd evennia/timmy_world
 evennia migrate
 evennia start
 ```
 
-Grounding:
-- `evennia/timmy_world/README.md`
-- `evennia/timmy_world/server/conf/settings.py`
-
-### 2. Web routing
-`evennia/timmy_world/web/urls.py` is the browser-facing entry point. It includes:
-- `web.website.urls`
-- `web.webclient.urls`
-- `web.admin.urls`
-- `evennia.web.urls` appended after the local patterns
-
-This means the effective surface inherits Evennia defaults rather than defining a custom Tower web application.
-
-### 3. Standalone simulation module
-`evennia/timmy_world/game.py` is a pure-Python entry point with:
-- `NARRATIVE_PHASES`
-- `get_narrative_phase()`
-- `get_phase_transition_event()`
-- `World`
-- `ActionSystem`
-- `NPCAI`
-- `GameEngine`
-- `PlayerInterface`
-
-This module can be imported and exercised without an Evennia runtime.
-
-### 4. Alternate simulation module
-`evennia/timmy_world/world/game.py` mirrors much of the same gameplay stack, but is not the one used by `play_200.py`.
-
-Important distinction:
-- root `game.py` is the active scripted demo target
-- `world/game.py` is a second engine implementation with overlapping responsibilities
-
-### 5. Scripted narrative demo
-`evennia/timmy_world/play_200.py` runs 200 deterministic ticks and prints a story arc across four named phases:
-- Quietus
-- Fracture
-- Breaking
-- Mending
-
-This file is the clearest executable artifact proving how the simulator is intended to be consumed outside Evennia.
+**AI Agent Connection (Timmy):**
+AI agents connect via Telnet on port 4000, authenticating as scripted accounts. The `Script` typeclass handles persistent NPC behavior.
 
 ## Data Flow
 
-### Networked Evennia path
-1. Client connects via telnet or browser.
-2. Evennia loads settings from `server/conf/settings.py`.
-3. Command set resolution flows through `commands/default_cmdsets.py`.
-4. Typeclass objects resolve through `typeclasses/accounts.py`, `typeclasses/characters.py`, `typeclasses/rooms.py`, `typeclasses/exits.py`, `typeclasses/objects.py`, and `typeclasses/scripts.py`.
-5. URL dispatch flows through `web/urls.py` into website, webclient, admin, and Evennia default URL patterns.
-6. Object/help/prototype metadata can be sourced from `world/prototypes.py` and `world/help_entries.py`.
-
-### Standalone Tower simulation path
-1. Operator imports `evennia/timmy_world/game.py` directly or runs `evennia/timmy_world/play_200.py`.
-2. `GameEngine.start_new_game()` initializes the world state.
-3. `PlayerInterface.get_available_actions()` exposes current verbs from room topology and nearby characters.
-4. `GameEngine.run_tick()` / `play_turn()` advances time, movement, world events, NPC actions, and logs.
-5. `World` tracks rooms, characters, trust, weather, forge/garden/bridge/tower state, and narrative phase.
-6. Persistence writes to JSON/log files rooted at `/Users/apayne/.timmy/evennia/timmy_world`.
-
-### Evidence of the persistence contract
-Both simulation modules hardcode the same portability-sensitive base path:
-- `evennia/timmy_world/game.py`
-- `evennia/timmy_world/world/game.py`
-
-Each defines:
-- `WORLD_DIR = Path('/Users/apayne/.timmy/evennia/timmy_world')`
-- `STATE_FILE = WORLD_DIR / 'game_state.json'`
-- `TIMMY_LOG = WORLD_DIR / 'timmy_log.md'`
+```
+Player/AI Input
+    |
+    v
+Portal (connection handling, Telnet/Web)
+    |
+    v
+Server (game logic, session management)
+    |
+    v
+Command Parser (cmdparser.py)
+    |
+    v
+Command Execution (commands/command.py)
+    |
+    v
+Typeclass Methods (characters.py, objects.py, etc.)
+    |
+    v
+Database (Django ORM)
+    |
+    v
+Output back through Portal to Player/AI
+```
 
 ## Key Abstractions
 
-### `World` — state container for the Tower
-Found in both `evennia/timmy_world/game.py` and `evennia/timmy_world/world/game.py`.
+### Object (typeclasses/objects.py) — 218 lines
+The core world entity. Everything in the game world inherits from Object:
+- **ObjectParent**: Mixin class for shared behavior across all object types
+- **Object**: Concrete game items, furniture, tools, NPCs without scripts
 
-Responsibilities:
-- defines the five-room map: Threshold, Tower, Forge, Garden, Bridge
-- stores per-room connections and dynamic state
-- stores per-character room, energy, trust, goals, memories, and inventory
-- tracks global pressure variables like `forge_fire_dying`, `garden_drought`, `bridge_flooding`, and `tower_power_low`
-- updates world time and environmental drift each tick
+Key methods: `at_init()`, `at_object_creation()`, `return_appearance()`, `at_desc()`
 
-### `ActionSystem`
-Also present in both engine files.
+### Character (typeclasses/characters.py)
+Puppetable entities. What players and AI agents control.
+- Inherits from Object and DefaultCharacter
+- Has location (Room), can hold objects, can execute commands
 
-Responsibilities:
-- enumerates available verbs
-- computes contextual action menus from world state
-- ties actions to energy cost and room/character context
+### Room (typeclasses/rooms.py)
+Spatial containers. No location of their own.
+- Contains Characters, Objects, and Exits
+- `return_appearance()` generates room descriptions
 
-### `NPCAI`
-The non-player decision layer.
+### Exit (typeclasses/exits.py)
+Connectors between Rooms. Always has a `destination` property.
+- Generates a command named after the exit
+- Moving through an exit = executing that command
 
-Responsibilities:
-- chooses actions based on each character's goals and situation
-- creates world motion without requiring live operator input
-- in `world/game.py`, works alongside `DialogueSystem`
+### Account (typeclasses/accounts.py) — 149 lines
+The persistent player identity. Survives across sessions.
+- Can puppet one Character at a time
+- Handles channels, tells, who list
+- Guest class for anonymous access
 
-### `GameEngine`
-The orchestration layer.
+### Script (typeclasses/scripts.py) — 104 lines
+Persistent background processes. No in-game existence.
+- Timers, periodic events, NPC AI loops
+- Key for AI agent integration
 
-Responsibilities:
-- bootstraps a fresh run with `start_new_game()`
-- rehydrates from storage via `load_game()`
-- advances the simulation with `run_tick()` / `play_turn()`
-- records log entries and world events
-
-Grounded interface details from live import of `evennia/timmy_world/game.py`:
-- methods visible on the instance: `load_game`, `log`, `play_turn`, `run_tick`, `start_new_game`
-- `play_turn('look')` returns a dict with keys:
-  - `tick`
-  - `time`
-  - `phase`
-  - `phase_name`
-  - `timmy_room`
-  - `timmy_energy`
-  - `room_desc`
-  - `here`
-  - `world_events`
-  - `npc_actions`
-  - `choices`
-  - `log`
-
-### `PlayerInterface`
-A thin operator-facing adapter.
-
-Grounded behavior:
-- when loaded from `evennia/timmy_world/game.py` after `start_new_game()`, `PlayerInterface(engine).get_available_actions()` exposes room navigation and social verbs like:
-  - `move:north -> Tower`
-  - `move:east -> Garden`
-  - `move:west -> Forge`
-  - `move:south -> Bridge`
-  - `speak:Allegro`
-  - `speak:Claude`
-  - `rest`
-
-### Evennia typeclasses and cmdsets
-The Evennia abstractions are real but thin.
-
-Notable files:
-- `evennia/timmy_world/typeclasses/objects.py`
-- `evennia/timmy_world/typeclasses/characters.py`
-- `evennia/timmy_world/typeclasses/rooms.py`
-- `evennia/timmy_world/typeclasses/exits.py`
-- `evennia/timmy_world/typeclasses/accounts.py`
-- `evennia/timmy_world/typeclasses/scripts.py`
-- `evennia/timmy_world/commands/command.py`
-- `evennia/timmy_world/commands/default_cmdsets.py`
-
-Today these mostly wrap Evennia defaults instead of implementing a custom Tower-specific protocol on top.
+### Command (commands/command.py) — 188 lines
+User input handlers. MUX-style command parsing.
+- `at_pre_cmd()` → `parse()` → `func()` → `at_post_cmd()`
+- Supports switches (`/flag`), left/right sides (`lhs = rhs`)
 
 ## API Surface
 
-### Network surfaces
-Grounded from `README.md`, `web/urls.py`, and `server/conf/mssp.py`:
-- Telnet on port `4000`
-- Browser / webclient on `http://localhost:4001`
-- admin surface under `/admin/`
-- Evennia default URLs appended via `evennia.web.urls`
-- Evennia REST/web surface inherits the default `/api/` patterns rather than defining custom project-specific endpoints here
-
-### Operator / script surfaces
-- `python3 evennia/timmy_world/play_200.py`
-- importable pure-Python engine in `evennia/timmy_world/game.py`
-- alternate engine in `evennia/timmy_world/world/game.py`
-
-### Content/model surfaces
-- object prototype definitions: `evennia/timmy_world/world/prototypes.py`
-- file-based help entries: `evennia/timmy_world/world/help_entries.py`
+| Endpoint | Type | Purpose |
+|----------|------|---------|
+| Telnet:4000 | MUD Protocol | Game connection |
+| /api/ | REST | Web API (Evennia default) |
+| /webclient/ | WebSocket | Browser game client |
+| /admin/ | HTTP | Django admin panel |
 
 ## Test Coverage Gaps
 
-### Current verified state
-The original genome here was stale. The live repo now shows two different categories of test coverage:
+**Current State:** No custom tests found.
 
-1. Host-repo generated tests already exist in `tests/test_genome_generated.py`
-   - they reference `evennia/timmy_world/game.py`
-   - they reference `evennia/timmy_world/world/game.py`
-   - they reference `server/conf/web_plugins.py`
-2. Those generated tests are not trustworthy as-is for this target
-   - running `python3 -m pytest tests/test_genome_generated.py -k 'EvenniaTimmyWorld' -q -rs`
-   - result: `19 skipped, 31 deselected`
-   - skip reason on every case: `Module not importable`
+**Missing Tests:**
+1. **Object lifecycle**: `at_object_creation`, `at_init`, `delete`
+2. **Room navigation**: Exit creation, movement between rooms
+3. **Command parsing**: Switch handling, lhs/rhs splitting
+4. **Account authentication**: Login flow, guest creation
+5. **Script persistence**: Start, stop, timer accuracy
+6. **Lock function evaluation**: Permission checks
+7. **AI agent integration**: Telnet connection, command execution as NPC
+8. **Spatial memory**: Room state tracking, object location queries
 
-This matters because the codebase-genome pipeline reported zero local tests for the subproject, but the host repo does contain tests. The real issue is not “no tests exist.” The real issue is “the existing generated tests are disconnected from the actual import path and therefore do not execute the critical path.”
-
-### New critical-path tests added for #677
-This issue refresh adds a dedicated executable test file:
-- `tests/test_evennia_local_world_game.py`
-
-Covered behaviors:
-- narrative phase boundaries across Quietus / Fracture / Breaking / Mending
-- player-facing action surface from the Threshold start state
-- deterministic `run_tick('move:north')` flow into the Tower with expected log and world-event output
-
-### Genome artifact coverage added for #677
-This issue refresh also adds:
-- `tests/test_evennia_local_world_genome.py`
-
-That test locks:
-- artifact path
-- required analysis sections
-- grounded snippets for real files and verification output
-
-### Remaining gaps
-Still missing strong runtime coverage for:
-- Evennia typeclass behavior under a real Evennia test harness
-- URL routing under Django/Evennia integration
-- `world/game.py` parity versus root `game.py`
-- persistence portability around `/Users/apayne/.timmy/evennia/timmy_world`
-- `at_initial_setup.py` and `world/batch_cmds.ev` actually building a playable world in the Evennia path
+**Recommended:** Add `tests/` directory with pytest-compatible Evennia tests.
 
 ## Security Considerations
 
-1. Plaintext telnet exposure
-   - `server/conf/mssp.py` advertises port `4000`
-   - telnet is unencrypted by default
-   - acceptable for localhost/dev, risky for exposed deployment
-
-2. Hardcoded absolute persistence path
-   - both `evennia/timmy_world/game.py` and `evennia/timmy_world/world/game.py` hardcode `/Users/apayne/.timmy/evennia/timmy_world`
-   - this couples runtime writes to one operator machine and one home-directory layout
-   - portability and accidental overwrite risk are both real
-   - filed follow-up: `timmy-home #831` — `https://forge.alexanderwhitestone.com/Timmy_Foundation/timmy-home/issues/831`
-
-3. Admin/web surfaces inherit defaults
-   - `web/urls.py` exposes admin and Evennia defaults
-   - if the service is made remotely reachable, Django/Evennia auth and proxy boundaries matter immediately
-
-4. Secret handling is externalized but optional
-   - `server/conf/settings.py` silently falls back if `secret_settings.py` is missing
-   - convenient for local development, but secrets discipline lives outside the repo contract
-
-5. Template hooks can hide missing security posture
-   - `server/conf/web_plugins.py` is pass-through
-   - `server/conf/at_initial_setup.py` is pass-through
-   - the absence of custom code here means there are no local hardening hooks yet for startup, proxying, or world bootstrap
+1. **Telnet is unencrypted** — All MUD traffic is plaintext. Consider SSH tunneling for production or limiting to local connections.
+2. **Lock functions** — Custom lockfuncs.py defines permission checks. Review for bypass vulnerabilities.
+3. **Web API** — Ensure Django admin is restricted to trusted IPs.
+4. **Guest accounts** — Guest class exists. Limit permissions to prevent abuse.
+5. **Script execution** — Scripts run server-side Python. Arbitrary script creation is a security risk if not locked down.
+6. **AI agent access** — Timmy connects as a regular account. Ensure agent accounts have appropriate permission limits.
 
 ## Dependencies
 
-Directly evidenced imports and framework coupling:
-- Evennia 6.0 game-directory structure
-- Django via Evennia web/admin stack
-- Twisted via Evennia networking/web hooks
-- Python stdlib heavy use in standalone simulator:
-  - `json`
-  - `time`
-  - `os`
-  - `random`
-  - `datetime`
-  - `pathlib`
-  - `sys`
+- **Evennia 6.0** — MUD/MUSH framework (Django + Twisted)
+- **Python 3.11+**
+- **Django** (bundled with Evennia)
+- **Twisted** (bundled with Evennia)
 
-Dependency caveat:
-- the standalone Tower simulator is largely pure Python and importable in isolation
-- the typeclass / cmdset / web files depend on Evennia and Django runtime wiring to do real work
+## Integration Points
 
-## Deployment
-
-### Evennia path
-```bash
-cd evennia/timmy_world
-evennia migrate
-evennia start
-```
-
-Expected local surfaces from repo docs/config:
-- telnet: `localhost:4000`
-- browser/webclient: `http://localhost:4001`
-
-### Standalone simulation path
-```bash
-cd evennia/timmy_world
-python3 play_200.py
-```
-
-This does not require the full Evennia network stack. It exercises the root `game.py` engine directly.
-
-### Verification commands run for this genome refresh
-```bash
-python3 ~/.hermes/pipelines/codebase-genome.py --path /tmp/BURN-7-7/evennia/timmy_world --output /tmp/evennia-local-world-GENOME-base.md
-python3 -m pytest tests/test_genome_generated.py -k 'EvenniaTimmyWorld' -q -rs
-python3 -m pytest tests/test_evennia_local_world_genome.py tests/test_evennia_local_world_game.py -q
-python3 -m py_compile evennia/timmy_world/game.py evennia/timmy_world/world/game.py evennia/timmy_world/play_200.py evennia/timmy_world/server/conf/settings.py evennia/timmy_world/web/urls.py
-```
-
-## Key Findings
-
-1. The current custom product logic is the standalone Tower simulator, not the Evennia typeclass layer.
-2. The repo contains two parallel simulation engines: `evennia/timmy_world/game.py` and `evennia/timmy_world/world/game.py`.
-3. The stock Evennia scaffolding is still mostly template code (`README.md`, `at_initial_setup.py`, `world/batch_cmds.ev`, pass-through cmdsets/web hooks).
-4. The codebase-genome pipeline undercounted test reality because subproject-local tests are absent while host-repo tests exist one level up.
-5. The existing generated tests were present but functionally inert: `19 skipped` because their import path does not match the current host-repo layout.
-6. The most concrete portability hazard is the hardcoded `/Users/apayne/.timmy/evennia/timmy_world` state path in both simulation engines.
+- **Timmy AI Agent** — Connects via Telnet, interacts as NPC
+- **Hermes** — Orchestrates Timmy instances that interact with the world
+- **Spatial Memory** — Room/object state tracked for AI context
+- **Federation** — Multiple Evennia worlds can be bridged (see evennia-federation skill)
 
 ---
 
-This refreshed genome supersedes the earlier auto-generated `evennia/timmy_world/GENOME.md` summary by grounding the analysis in live source inspection, live import of `evennia/timmy_world/game.py`, current file metrics, and executable host-repo verification.
+*Generated: Codebase Genome for evennia-local-world (timmy_home #677)*

evennia_tools/batch_cmds_bezalel.ev

@@ -0,0 +1,110 @@
+#
+# Bezalel World Builder — Evennia batch commands
+# Creates the Bezalel Evennia world from evennia_tools/bezalel_layout.py specs.
+#
+# Load with: @batchcommand bezalel_world
+#
+# Part of #536
+
+# Create rooms
+@create/drop Limbo:evennia.objects.objects.DefaultRoom
+@desc here = The void between worlds. The air carries the pulse of three houses: Mac, VPS, and this one. Everything begins here before it is given form.
+
+@create/drop Gatehouse:evennia.objects.objects.DefaultRoom
+@desc here = A stone guard tower at the edge of Bezalel world. The walls are carved with runes of travel, proof, and return. Every arrival is weighed before it is trusted.
+
+@create/drop Great Hall:evennia.objects.objects.DefaultRoom
+@desc here = A vast hall with a long working table. Maps of the three houses hang beside sketches, benchmarks, and deployment notes. This is where the forge reports back to the house.
+
+@create/drop The Library of Bezalel:evennia.objects.objects.DefaultRoom
+@desc here = Shelves of technical manuals, Evennia code, test logs, and bridge schematics rise to the ceiling. This room holds plans waiting to be made real.
+
+@create/drop The Observatory:evennia.objects.objects.DefaultRoom
+@desc here = A high chamber with telescopes pointing toward the Mac, the VPS, and the wider net. Screens glow with status lights, latency traces, and long-range signals.
+
+@create/drop The Workshop:evennia.objects.objects.DefaultRoom
+@desc here = A forge and workbench share the same heat. Scattered here are half-finished bridges, patched harnesses, and tools laid out for proof before pride.
+
+@create/drop The Server Room:evennia.objects.objects.DefaultRoom
+@desc here = Racks of humming servers line the walls. Fans push warm air through the chamber while status LEDs beat like a mechanical heart. This is the pulse of Bezalel house.
+
+@create/drop The Garden of Code:evennia.objects.objects.DefaultRoom
+@desc here = A quiet garden where ideas are left long enough to grow roots. Code-shaped leaves flutter in patterned wind, and a stone path invites patient thought.
+
+@create/drop The Portal Room:evennia.objects.objects.DefaultRoom
+@desc here = Three shimmering doorways stand in a ring: one marked for the Mac house, one for the VPS, and one for the wider net. The room hums like a bridge waiting for traffic.
+
+# Create exits
+@open gatehouse:gate,tower = Gatehouse
+@open limbo:void,back = Limbo
+@open greathall:hall,great hall = Great Hall
+@open gatehouse:gate,tower = Gatehouse
+@open library:books,study = The Library of Bezalel
+@open hall:great hall,back = Great Hall
+@open observatory:telescope,tower top = The Observatory
+@open hall:great hall,back = Great Hall
+@open workshop:forge,bench = The Workshop
+@open hall:great hall,back = Great Hall
+@open serverroom:servers,server room = The Server Room
+@open workshop:forge,bench = The Workshop
+@open garden:garden of code,grove = The Garden of Code
+@open workshop:forge,bench = The Workshop
+@open portalroom:portal,portals = The Portal Room
+@open gatehouse:gate,back = Gatehouse
+
+# Create objects
+@create Threshold Ledger
+@desc Threshold Ledger = A heavy ledger where arrivals, departures, and field notes are recorded before the work begins.
+@tel Threshold Ledger = Gatehouse
+
+@create Three-House Map
+@desc Three-House Map = A long map showing Mac, VPS, and remote edges in one continuous line of work.
+@tel Three-House Map = Great Hall
+
+@create Bridge Schematics
+@desc Bridge Schematics = Rolled plans describing world bridges, Evennia layouts, and deployment paths.
+@tel Bridge Schematics = The Library of Bezalel
+
+@create Compiler Manuals
+@desc Compiler Manuals = Manuals annotated in the margins with warnings against cleverness without proof.
+@tel Compiler Manuals = The Library of Bezalel
+
+@create Tri-Axis Telescope
+@desc Tri-Axis Telescope = A brass telescope assembly that can be turned toward the Mac, the VPS, or the open net.
+@tel Tri-Axis Telescope = The Observatory
+
+@create Forge Anvil
+@desc Forge Anvil = Scarred metal used for turning rough plans into testable form.
+@tel Forge Anvil = The Workshop
+
+@create Bridge Workbench
+@desc Bridge Workbench = A wide bench covered in harness patches, relay notes, and half-soldered bridge parts.
+@tel Bridge Workbench = The Workshop
+
+@create Heartbeat Console
+@desc Heartbeat Console = A monitoring console showing service health, latency, and the steady hum of the house.
+@tel Heartbeat Console = The Server Room
+
+@create Server Racks
+@desc Server Racks = Stacked machines that keep the world awake even when no one is watching.
+@tel Server Racks = The Server Room
+
+@create Code Orchard
+@desc Code Orchard = Trees with code-shaped leaves. Some branches bear elegant abstractions; others hold broken prototypes.
+@tel Code Orchard = The Garden of Code
+
+@create Stone Bench
+@desc Stone Bench = A place to sit long enough for a hard implementation problem to become clear.
+@tel Stone Bench = The Garden of Code
+
+@create Mac Portal:mac arch
+@desc Mac Portal = A silver doorway whose frame vibrates with the local sovereign house.
+@tel Mac Portal = The Portal Room
+
+@create VPS Portal:vps arch
+@desc VPS Portal = A cobalt doorway tuned toward the testbed VPS house.
+@tel VPS Portal = The Portal Room
+
+@create Net Portal:net arch,network arch
+@desc Net Portal = A pale doorway pointed toward the wider net and every uncertain edge beyond it.
+@tel Net Portal = The Portal Room

evennia_tools/build_bezalel_world.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+""
+build_bezalel_world.py — Build Bezalel Evennia world from layout specs.
+
+Programmatically creates rooms, exits, objects, and characters in a running
+Evennia instance using the specs from evennia_tools/bezalel_layout.py.
+
+Usage (in Evennia game shell):
+    from evennia_tools.build_bezalel_world import build_world
+    build_world()
+
+Or via batch command:
+    @batchcommand evennia_tools/batch_cmds_bezalel.ev
+
+Part of #536
+""
+
+from evennia_tools.bezalel_layout import (
+    ROOMS, EXITS, OBJECTS, CHARACTERS, PORTAL_COMMANDS,
+    room_keys, reachable_rooms_from
+)
+
+
+def build_world():
+    """Build the Bezalel Evennia world from layout specs."""
+    from evennia.objects.models import ObjectDB
+    from evennia.utils.create import create_object, create_exit, create_message
+
+    print("Building Bezalel world...")
+
+    # Create rooms
+    rooms = {}
+    for spec in ROOMS:
+        room = create_object(
+            "evennia.objects.objects.DefaultRoom",
+            key=spec.key,
+            attributes=(("desc", spec.desc),),
+        )
+        rooms[spec.key] = room
+        print(f"  Room: {spec.key}")
+
+    # Create exits
+    for spec in EXITS:
+        source = rooms.get(spec.source)
+        dest = rooms.get(spec.destination)
+        if not source or not dest:
+            print(f"  WARNING: Exit {spec.key} — missing room")
+            continue
+        exit_obj = create_exit(
+            key=spec.key,
+            location=source,
+            destination=dest,
+            aliases=list(spec.aliases),
+        )
+        print(f"  Exit: {spec.source} -> {spec.destination} ({spec.key})")
+
+    # Create objects
+    for spec in OBJECTS:
+        location = rooms.get(spec.location)
+        if not location:
+            print(f"  WARNING: Object {spec.key} — missing room {spec.location}")
+            continue
+        obj = create_object(
+            "evennia.objects.objects.DefaultObject",
+            key=spec.key,
+            location=location,
+            attributes=(("desc", spec.desc),),
+            aliases=list(spec.aliases),
+        )
+        print(f"  Object: {spec.key} in {spec.location}")
+
+    # Verify reachability
+    all_rooms = set(room_keys())
+    reachable = reachable_rooms_from("Limbo")
+    unreachable = all_rooms - reachable
+    if unreachable:
+        print(f"  WARNING: Unreachable rooms: {unreachable}")
+    else:
+        print(f"  All {len(all_rooms)} rooms reachable from Limbo")
+
+    print("Bezalel world built.")
+
+
+if __name__ == "__main__":
+    build_world()

genomes/burn-fleet/GENOME.md

@@ -1,101 +0,0 @@
-# GENOME.md — Burn Fleet (Timmy_Foundation/burn-fleet)
-
-> Codebase Genome v1.0 | Generated 2026-04-16 | Repo 14/16
-
-## Project Overview
-
-**Burn Fleet** is the autonomous dispatch infrastructure for the Timmy Foundation. It manages 112 tmux panes across Mac and VPS, routing Gitea issues to lane-specialized workers by repo. Each agent has a mythological name — they are all Timmy with different hats.
-
-**Core principle:** Dispatch ALL panes. Never scan for idle. Stale work beats idle workers.
-
-## Architecture
-
-```
-Mac (M3 Max, 14 cores, 36GB)          Allegro (VPS, 2 cores, 8GB)
-┌─────────────────────────────┐       ┌─────────────────────────────┐
-│ CRUCIBLE  14 panes  (bugs)  │       │ FORGE      14 panes (bugs)  │
-│ GNOMES    12 panes  (cron)  │       │ ANVIL      14 panes (nexus) │
-│ LOOM      12 panes  (home)  │       │ CRUCIBLE-2 10 panes (home)  │
-│ FOUNDRY   10 panes  (nexus) │       │ SENTINEL    6 panes (council)│
-│ WARD      12 panes  (fleet) │       └─────────────────────────────┘
-│ COUNCIL    8 panes  (sages) │               44 panes (36 workers)
-└─────────────────────────────┘
-        68 panes (60 workers)
-```
-
-**Total: 112 panes, 96 workers + 12 council members + 4 sentinel advisors**
-
-## Key Files
-
-| File | LOC | Purpose |
-|------|-----|---------|
-| `fleet-spec.json` | ~200 | Machine definitions, window layouts, lane assignments, agent names |
-| `fleet-launch.sh` | ~100 | Create tmux sessions with correct pane counts on Mac + Allegro |
-| `fleet-christen.py` | ~80 | Launch hermes in all panes and send identity messages |
-| `fleet-dispatch.py` | ~250 | Pull Gitea issues and route to correct panes by lane |
-| `fleet-status.py` | ~100 | Health check across all machines |
-| `allegro/docker-compose.yml` | ~30 | Allegro VPS container definition |
-| `allegro/Dockerfile` | ~20 | Allegro build definition |
-| `allegro/healthcheck.py` | ~15 | Allegro container health check |
-
-**Total: ~800 LOC**
-
-## Lane Routing
-
-Issues are routed by repo to the correct window:
-
-| Repo | Mac Window | Allegro Window |
-|------|-----------|----------------|
-| hermes-agent | CRUCIBLE, GNOMES | FORGE |
-| timmy-home | LOOM | CRUCIBLE-2 |
-| timmy-config | LOOM | CRUCIBLE-2 |
-| the-nexus | FOUNDRY | ANVIL |
-| the-playground | — | ANVIL |
-| the-door | WARD | CRUCIBLE-2 |
-| fleet-ops | WARD | CRUCIBLE-2 |
-| turboquant | WARD | — |
-
-## Entry Points
-
-| Command | Purpose |
-|---------|---------|
-| `./fleet-launch.sh both` | Create tmux layout on Mac + Allegro |
-| `python3 fleet-christen.py both` | Wake all agents with identity messages |
-| `python3 fleet-dispatch.py --cycles 1` | Single dispatch cycle |
-| `python3 fleet-dispatch.py --cycles 10 --interval 60` | Continuous burn (10 cycles, 60s apart) |
-| `python3 fleet-status.py` | Health check all machines |
-
-## Agent Names
-
-| Window | Names | Count |
-|--------|-------|-------|
-| CRUCIBLE | AZOTH, ALBEDO, CITRINITAS, RUBEDO, SULPHUR, MERCURIUS, SAL, ATHANOR, VITRIOL, SATURN, JUPITER, MARS, EARTH, SOL | 14 |
-| GNOMES | RAZIEL, AZRAEL, CASSIEL, METATRON, SANDALPHON, BINAH, CHOKMAH, KETER, ALDEBARAN, RIGEL, SIRIUS, POLARIS | 12 |
-| FORGE | HAMMER, ANVIL, ADZE, PICK, TONGS, WRENCH, SCREWDRIVER, BOLT, SAW, TRAP, HOOK, MAGNET, SPARK, FLAME | 14 |
-| COUNCIL | TESLA, HERMES, GANDALF, DAVINCI, ARCHIMEDES, TURING, AURELIUS, SOLOMON | 8 |
-
-## Design Decisions
-
-1. **Separate GILs** — Allegro runs Python independently on VPS for true parallelism
-2. **Queue, not send-keys** — Workers process at their own pace, no interruption
-3. **Lane enforcement** — Panes stay in one repo to build deep context
-4. **Dispatch ALL panes** — Never scan for idle; stale work beats idle workers
-5. **Council is advisory** — Named archetypes provide perspective, not task execution
-
-## Scaling
-
-- Add panes: Edit `fleet-spec.json` → `fleet-launch.sh` → `fleet-christen.py`
-- Add machines: Edit `fleet-spec.json` → Add routing in `fleet-dispatch.py` → Ensure SSH access
-
-## Sovereignty Assessment
-
-- **Fully local** — Mac + user-controlled VPS, no cloud dependencies
-- **No phone-home** — Gitea API is self-hosted
-- **Open source** — All code on Gitea
-- **SSH-based** — Mac → Allegro communication via SSH only
-
-**Verdict: Fully sovereign. Autonomous fleet dispatch with no external dependencies.**
-
----
-
-*"Dispatch ALL panes. Never scan for idle — stale work beats idle workers."*

reports/evaluations/2026-04-07-mempalace-v3-evaluation.md

@@ -1,106 +0,0 @@
-# MemPalace v3.0.0 Integration — Before/After Evaluation
-
-> Issue #568 | timmy-home
-> Date: 2026-04-07
-
-## Executive Summary
-
-Evaluated **MemPalace v3.0.0** as a memory layer for the Timmy/Hermes agent stack.
-
-**Installed:** ✅ `mempalace 3.0.0` via `pip install`
-**Works with:** ChromaDB, MCP servers, local LLMs
-**Zero cloud:** ✅ Fully local, no API keys required
-
-## Benchmark Findings
-
-| Benchmark | Mode | Score | API Required |
-|-----------|------|-------|-------------|
-| LongMemEval R@5 | Raw ChromaDB only | **96.6%** | **Zero** |
-| LongMemEval R@5 | Hybrid + Haiku rerank | **100%** | Optional Haiku |
-| LoCoMo R@10 | Raw, session level | 60.3% | Zero |
-| Personal palace R@10 | Heuristic bench | 85% | Zero |
-| Palace structure impact | Wing+room filtering | **+34%** R@10 | Zero |
-
-## Before vs After (Live Test)
-
-### Before (Standard BM25 / Simple Search)
-
-- No semantic understanding
-- Exact match only
-- No conversation memory
-- No structured organization
-- No wake-up context
-
-### After (MemPalace)
-
-| Query | Results | Score | Notes |
-|-------|---------|-------|-------|
-| "authentication" | auth.md, main.py | -0.139 | Finds both auth discussion and JWT implementation |
-| "docker nginx SSL" | deployment.md, auth.md | 0.447 | Exact match on deployment, related JWT context |
-| "keycloak OAuth" | auth.md, main.py | -0.029 | Finds OAuth discussion and JWT usage |
-| "postgresql database" | README.md, main.py | 0.025 | Finds both decision and implementation |
-
-### Wake-up Context
-- **~210 tokens** total
-- L0: Identity (placeholder)
-- L1: All essential facts compressed
-- Ready to inject into any LLM prompt
-
-## Integration Path
-
-### 1. Memory Mining
-```bash
-mempalace mine ~/.hermes/sessions/ --mode convos
-mempalace mine ~/.hermes/hermes-agent/
-mempalace mine ~/.hermes/
-```
-
-### 2. Wake-up Protocol
-```bash
-mempalace wake-up > /tmp/timmy-context.txt
-```
-
-### 3. MCP Integration
-```bash
-hermes mcp add mempalace -- python -m mempalace.mcp_server
-```
-
-### 4. Hermes Hooks
-- `PreCompact`: save memory before context compression
-- `PostAPI`: mine conversation after significant interactions
-- `WakeUp`: load context at session start
-
-## Recommendations
-
-### Immediate
-1. Add `mempalace` to Hermes venv requirements
-2. Create mine script for ~/.hermes/ and ~/.timmy/
-3. Add wake-up hook to Hermes session start
-4. Test with real conversation exports
-
-### Short-term
-1. Mine last 30 days of Timmy sessions
-2. Build wake-up context for all agents
-3. Add MemPalace MCP tools to Hermes toolset
-4. Test retrieval quality on real queries
-
-### Medium-term
-1. Replace homebrew memory system with MemPalace
-2. Build palace structure: wings for projects, halls for topics
-3. Compress with AAAK for 30x storage efficiency
-4. Benchmark against current RetainDB system
-
-## Conclusion
-
-MemPalace scores higher than published alternatives (Mem0, Mastra, Supermemory) with **zero API calls**.
-
-Key advantages:
-1. **Verbatim retrieval** — never loses the "why" context
-2. **Palace structure** — +34% boost from organization
-3. **Local-only** — aligns with sovereignty mandate
-4. **MCP compatible** — drops into existing tool chain
-5. **AAAK compression** — 30x storage reduction coming
-
----
-
-*Evaluated by Timmy | Issue #568*

scripts/genome_analyzer.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""
+genome_analyzer.py — Generate a GENOME.md from a codebase.
+
+Scans a repository and produces a structured codebase genome with:
+- File counts by type
+- Architecture overview (directory structure)
+- Entry points
+- Test coverage summary
+
+Usage:
+    python3 scripts/genome_analyzer.py /path/to/repo
+    python3 scripts/genome_analyzer.py /path/to/repo --output GENOME.md
+    python3 scripts/genome_analyzer.py /path/to/repo --dry-run
+
+Part of #666: GENOME.md Template + Single-Repo Analyzer.
+"""
+
+import argparse
+import sys
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+SKIP_DIRS = {".git", "__pycache__", ".venv", "venv", "node_modules", ".tox", ".pytest_cache", ".DS_Store"}
+
+
+def count_files(repo_path: Path) -> Dict[str, int]:
+    counts = defaultdict(int)
+    for f in repo_path.rglob("*"):
+        if any(part in SKIP_DIRS for part in f.parts):
+            continue
+        if f.is_file():
+            ext = f.suffix or "(no ext)"
+            counts[ext] += 1
+    return dict(sorted(counts.items(), key=lambda x: -x[1]))
+
+
+def find_entry_points(repo_path: Path) -> List[str]:
+    entry_points = []
+    candidates = [
+        "main.py", "app.py", "server.py", "cli.py", "manage.py",
+        "index.html", "index.js", "index.ts",
+        "Makefile", "Dockerfile", "docker-compose.yml",
+        "README.md", "deploy.sh", "setup.py", "pyproject.toml",
+    ]
+    for name in candidates:
+        if (repo_path / name).exists():
+            entry_points.append(name)
+    scripts_dir = repo_path / "scripts"
+    if scripts_dir.is_dir():
+        for f in sorted(scripts_dir.iterdir()):
+            if f.suffix in (".py", ".sh") and not f.name.startswith("test_"):
+                entry_points.append(f"scripts/{f.name}")
+    return entry_points[:15]
+
+
+def find_tests(repo_path: Path) -> Tuple[List[str], int]:
+    test_files = []
+    for f in repo_path.rglob("*"):
+        if any(part in SKIP_DIRS for part in f.parts):
+            continue
+        if f.is_file() and (f.name.startswith("test_") or f.name.endswith("_test.py") or f.name.endswith("_test.js")):
+            test_files.append(str(f.relative_to(repo_path)))
+    return sorted(test_files), len(test_files)
+
+
+def find_directories(repo_path: Path, max_depth: int = 2) -> List[str]:
+    dirs = []
+    for d in sorted(repo_path.rglob("*")):
+        if d.is_dir() and len(d.relative_to(repo_path).parts) <= max_depth:
+            if not any(part in SKIP_DIRS for part in d.parts):
+                rel = str(d.relative_to(repo_path))
+                if rel != ".":
+                    dirs.append(rel)
+    return dirs[:30]
+
+
+def read_readme(repo_path: Path) -> str:
+    for name in ["README.md", "README.rst", "README.txt", "README"]:
+        readme = repo_path / name
+        if readme.exists():
+            lines = readme.read_text(encoding="utf-8", errors="replace").split("\n")
+            para = []
+            started = False
+            for line in lines:
+                if line.startswith("#") and not started:
+                    continue
+                if line.strip():
+                    started = True
+                    para.append(line.strip())
+                elif started:
+                    break
+            return " ".join(para[:5])
+    return "(no README found)"
+
+
+def generate_genome(repo_path: Path, repo_name: str = "") -> str:
+    if not repo_name:
+        repo_name = repo_path.name
+    date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    readme_desc = read_readme(repo_path)
+    file_counts = count_files(repo_path)
+    total_files = sum(file_counts.values())
+    entry_points = find_entry_points(repo_path)
+    test_files, test_count = find_tests(repo_path)
+    dirs = find_directories(repo_path)
+
+    lines = [
+        f"# GENOME.md — {repo_name}", "",
+        f"> Codebase analysis generated {date}. {readme_desc[:100]}.", "",
+        "## Project Overview", "",
+        readme_desc, "",
+        f"**{total_files} files** across {len(file_counts)} file types.", "",
+        "## Architecture", "",
+        "```",
+    ]
+    for d in dirs[:20]:
+        lines.append(f"  {d}/")
+    lines.append("```")
+    lines += ["", "### File Types", "", "| Type | Count |", "|------|-------|"]
+    for ext, count in list(file_counts.items())[:15]:
+        lines.append(f"| {ext} | {count} |")
+    lines += ["", "## Entry Points", ""]
+    for ep in entry_points:
+        lines.append(f"- `{ep}`")
+    lines += ["", "## Test Coverage", "", f"**{test_count} test files** found.", ""]
+    if test_files:
+        for tf in test_files[:10]:
+            lines.append(f"- `{tf}`")
+        if len(test_files) > 10:
+            lines.append(f"- ... and {len(test_files) - 10} more")
+    else:
+        lines.append("No test files found.")
+    lines += ["", "## Security Considerations", "", "(To be filled during analysis)", ""]
+    lines += ["## Design Decisions", "", "(To be filled during analysis)", ""]
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate GENOME.md from a codebase")
+    parser.add_argument("repo_path", help="Path to repository")
+    parser.add_argument("--output", default="", help="Output file (default: stdout)")
+    parser.add_argument("--name", default="", help="Repository name")
+    parser.add_argument("--dry-run", action="store_true", help="Print stats only")
+    args = parser.parse_args()
+    repo_path = Path(args.repo_path).resolve()
+    if not repo_path.is_dir():
+        print(f"ERROR: {repo_path} is not a directory", file=sys.stderr)
+        sys.exit(1)
+    repo_name = args.name or repo_path.name
+    if args.dry_run:
+        counts = count_files(repo_path)
+        _, test_count = find_tests(repo_path)
+        print(f"Repo: {repo_name}")
+        print(f"Total files: {sum(counts.values())}")
+        print(f"Test files: {test_count}")
+        print(f"Top types: {', '.join(f'{k}={v}' for k,v in list(counts.items())[:5])}")
+        sys.exit(0)
+    genome = generate_genome(repo_path, repo_name)
+    if args.output:
+        with open(args.output, "w") as f:
+            f.write(genome)
+        print(f"Written: {args.output}")
+    else:
+        print(genome)
+
+
+if __name__ == "__main__":
+    main()

templates/GENOME-template.md

@@ -0,0 +1,46 @@
+# GENOME.md — {{REPO_NAME}}
+
+> Codebase analysis generated {{DATE}}. {{SHORT_DESCRIPTION}}.
+
+## Project Overview
+
+{{OVERVIEW}}
+
+## Architecture
+
+{{ARCHITECTURE_DIAGRAM}}
+
+## Entry Points
+
+{{ENTRY_POINTS}}
+
+## Data Flow
+
+{{DATA_FLOW}}
+
+## Key Abstractions
+
+{{ABSTRACTIONS}}
+
+## API Surface
+
+{{API_SURFACE}}
+
+## Test Coverage
+
+### Existing Tests
+{{EXISTING_TESTS}}
+
+### Coverage Gaps
+{{COVERAGE_GAPS}}
+
+### Critical paths that need tests:
+{{CRITICAL_PATHS}}
+
+## Security Considerations
+
+{{SECURITY}}
+
+## Design Decisions
+
+{{DESIGN_DECISIONS}}

tests/test_evennia_local_world_game.py

@@ -1,71 +0,0 @@
-from importlib.util import module_from_spec, spec_from_file_location
-from pathlib import Path
-import unittest
-
-
-ROOT = Path(__file__).resolve().parent.parent
-GAME_PATH = ROOT / "evennia" / "timmy_world" / "game.py"
-
-
-def load_game_module():
-    spec = spec_from_file_location("evennia_local_world_game", GAME_PATH)
-    module = module_from_spec(spec)
-    assert spec.loader is not None
-    spec.loader.exec_module(module)
-    module.random.seed(0)
-    return module
-
-
-class TestEvenniaLocalWorldGame(unittest.TestCase):
-    def test_narrative_phase_boundaries(self):
-        module = load_game_module()
-        expected = {
-            1: "quietus",
-            50: "quietus",
-            51: "fracture",
-            100: "fracture",
-            101: "breaking",
-            150: "breaking",
-            151: "mending",
-            999: "mending",
-        }
-        for tick, phase_name in expected.items():
-            with self.subTest(tick=tick):
-                phase, details = module.get_narrative_phase(tick)
-                self.assertEqual(phase, phase_name)
-                self.assertEqual(details["name"], module.NARRATIVE_PHASES[phase_name]["name"])
-
-    def test_player_interface_exposes_room_navigation_and_social_actions(self):
-        module = load_game_module()
-        engine = module.GameEngine()
-        engine.start_new_game()
-
-        actions = module.PlayerInterface(engine).get_available_actions()
-
-        self.assertIn("move:north -> Tower", actions)
-        self.assertIn("move:east -> Garden", actions)
-        self.assertIn("move:west -> Forge", actions)
-        self.assertIn("move:south -> Bridge", actions)
-        self.assertIn("speak:Allegro", actions)
-        self.assertIn("speak:Claude", actions)
-        self.assertIn("rest", actions)
-
-    def test_run_tick_moves_timmy_into_tower_and_reports_world_state(self):
-        module = load_game_module()
-        engine = module.GameEngine()
-        engine.start_new_game()
-
-        result = engine.run_tick("move:north")
-
-        self.assertEqual(result["tick"], 1)
-        self.assertEqual(engine.world.characters["Timmy"]["room"], "Tower")
-        self.assertEqual(result["timmy_room"], "Tower")
-        self.assertEqual(result["phase"], "quietus")
-        self.assertEqual(result["phase_name"], "Quietus")
-        self.assertIn("You move north to The Tower.", result["log"])
-        self.assertIn("Ezra is already here.", result["log"])
-        self.assertIn("The servers hum steady. The green LED pulses.", result["world_events"])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_evennia_local_world_genome.py

@@ -1,52 +0,0 @@
-from pathlib import Path
-import unittest
-
-
-ROOT = Path(__file__).resolve().parent.parent
-GENOME_PATH = ROOT / "evennia" / "timmy_world" / "GENOME.md"
-
-
-class TestEvenniaLocalWorldGenome(unittest.TestCase):
-    def test_genome_file_exists_with_required_sections(self):
-        self.assertTrue(GENOME_PATH.exists(), "missing evennia/timmy_world/GENOME.md")
-        text = GENOME_PATH.read_text(encoding="utf-8")
-        required_sections = [
-            "# GENOME.md — evennia-local-world",
-            "## Project Overview",
-            "## Architecture",
-            "## Entry Points",
-            "## Data Flow",
-            "## Key Abstractions",
-            "## API Surface",
-            "## Test Coverage Gaps",
-            "## Security Considerations",
-            "## Deployment",
-        ]
-        for section in required_sections:
-            self.assertIn(section, text)
-
-    def test_genome_names_current_runtime_truth_and_verification(self):
-        text = GENOME_PATH.read_text(encoding="utf-8")
-        required_snippets = [
-            "```mermaid",
-            "evennia/timmy_world/game.py",
-            "evennia/timmy_world/world/game.py",
-            "evennia/timmy_world/play_200.py",
-            "tests/test_genome_generated.py",
-            "tests/test_evennia_local_world_game.py",
-            "/Users/apayne/.timmy/evennia/timmy_world",
-            "43 Python files",
-            "4,985",
-            "19 skipped",
-        ]
-        for snippet in required_snippets:
-            self.assertIn(snippet, text)
-
-    def test_genome_is_substantial(self):
-        text = GENOME_PATH.read_text(encoding="utf-8")
-        self.assertGreaterEqual(len(text.splitlines()), 120)
-        self.assertGreaterEqual(len(text), 7000)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_the_nexus_genome.py

@@ -1,56 +0,0 @@
-from pathlib import Path
-
-
-GENOME = Path("GENOME.md")
-
-
-def read_genome() -> str:
-    assert GENOME.exists(), "GENOME.md must exist at repo root"
-    return GENOME.read_text(encoding="utf-8")
-
-
-def test_the_nexus_genome_has_required_sections() -> None:
-    text = read_genome()
-    required = [
-        "# GENOME.md — the-nexus",
-        "## Project Overview",
-        "## Architecture Diagram",
-        "```mermaid",
-        "## Entry Points and Data Flow",
-        "## Key Abstractions",
-        "## API Surface",
-        "## Test Coverage Gaps",
-        "## Security Considerations",
-        "## Runtime Truth and Docs Drift",
-    ]
-    missing = [item for item in required if item not in text]
-    assert not missing, missing
-
-
-def test_the_nexus_genome_captures_current_runtime_contract() -> None:
-    text = read_genome()
-    required = [
-        "server.py",
-        "app.js",
-        "index.html",
-        "portals.json",
-        "vision.json",
-        "BROWSER_CONTRACT.md",
-        "tests/test_browser_smoke.py",
-        "tests/test_repo_truth.py",
-        "nexus/morrowind_harness.py",
-        "nexus/bannerlord_harness.py",
-        "mempalace/tunnel_sync.py",
-        "mcp_servers/desktop_control_server.py",
-        "public/nexus/",
-    ]
-    missing = [item for item in required if item not in text]
-    assert not missing, missing
-
-
-def test_the_nexus_genome_explains_docs_runtime_drift() -> None:
-    text = read_genome()
-    assert "README.md says current `main` does not ship a browser 3D world" in text
-    assert "CLAUDE.md declares root `app.js` and `index.html` as canonical frontend paths" in text
-    assert "tests and browser contract now assume the root frontend exists" in text
-    assert len(text) >= 5000