fix: extract clean_lines/parse_room_output/normalize_event to module level (#1509)

Test file imports clean_lines, parse_room_output, normalize_event from
nexus.evennia_ws_bridge, but they were nested inside playback() function.
Moved all three to module level so they're importable.

Also moved actor_located/command_issued/command_result/room_snapshot/session_bound
imports from nested playback() to module-level import block.

playback() now calls module-level functions directly.

.gitea/workflows/auto-assign-reviewers.yml

@@ -1,160 +0,0 @@
-# .gitea/workflows/auto-assign-reviewers.yml
-# Automated reviewer assignment for PRs
-# Issue #1444: policy: Implement automated reviewer assignment
-
-name: Auto-Assign Reviewers
-
-on:
-  pull_request:
-    types: [opened, reopened, ready_for_review]
-
-jobs:
-  auto-assign:
-    runs-on: ubuntu-latest
-    if: github.event.pull_request.draft == false
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-      
-      - name: Auto-assign reviewers
-        env:
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          REPO: ${{ github.repository }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login }}
-        run: |
-          echo "Auto-assigning reviewers for PR #$PR_NUMBER"
-          echo "Repository: $REPO"
-          echo "PR Author: $PR_AUTHOR"
-          
-          # Get repository name
-          REPO_NAME=$(basename "$REPO")
-          
-          # Define default reviewers based on repository
-          case "$REPO_NAME" in
-            "hermes-agent")
-              DEFAULT_REVIEWERS=("Timmy" "perplexity")
-              REQUIRED_REVIEWERS=("Timmy")
-              ;;
-            "the-nexus")
-              DEFAULT_REVIEWERS=("perplexity")
-              REQUIRED_REVIEWERS=()
-              ;;
-            "timmy-home")
-              DEFAULT_REVIEWERS=("perplexity")
-              REQUIRED_REVIEWERS=()
-              ;;
-            "timmy-config")
-              DEFAULT_REVIEWERS=("perplexity")
-              REQUIRED_REVIEWERS=()
-              ;;
-            *)
-              DEFAULT_REVIEWERS=("perplexity")
-              REQUIRED_REVIEWERS=()
-              ;;
-          esac
-          
-          # Combine default and required reviewers
-          ALL_REVIEWERS=("${DEFAULT_REVIEWERS[@]}" "${REQUIRED_REVIEWERS[@]}")
-          
-          # Remove duplicates
-          UNIQUE_REVIEWERS=($(echo "${ALL_REVIEWERS[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' '))
-          
-          # Remove PR author from reviewers (can't review own PR)
-          FINAL_REVIEWERS=()
-          for reviewer in "${UNIQUE_REVIEWERS[@]}"; do
-            if [ "$reviewer" != "$PR_AUTHOR" ]; then
-              FINAL_REVIEWERS+=("$reviewer")
-            fi
-          done
-          
-          # Check if we have any reviewers
-          if [ ${#FINAL_REVIEWERS[@]} -eq 0 ]; then
-            echo "⚠️ WARNING: No reviewers available (author is only reviewer)"
-            echo "Adding fallback reviewer: perplexity"
-            FINAL_REVIEWERS=("perplexity")
-          fi
-          
-          echo "Assigning reviewers: ${FINAL_REVIEWERS[*]}"
-          
-          # Assign reviewers via Gitea API
-          for reviewer in "${FINAL_REVIEWERS[@]}"; do
-            echo "Assigning $reviewer as reviewer..."
-            
-            # Use Gitea API to request reviewer
-            RESPONSE=$(curl -s -w "%{http_code}" -X POST \
-              "https://forge.alexanderwhitestone.com/api/v1/repos/$REPO/pulls/$PR_NUMBER/requested_reviewers" \
-              -H "Authorization: token $GITEA_TOKEN" \
-              -H "Content-Type: application/json" \
-              -d "{\"reviewers\": [\"$reviewer\"]}")
-            
-            HTTP_CODE="${RESPONSE: -3}"
-            RESPONSE_BODY="${RESPONSE:0:${#RESPONSE}-3}"
-            
-            if [ "$HTTP_CODE" -eq 201 ]; then
-              echo "✅ Successfully assigned $reviewer as reviewer"
-            elif [ "$HTTP_CODE" -eq 422 ]; then
-              echo "⚠️ $reviewer is already a reviewer or cannot be assigned"
-            else
-              echo "❌ Failed to assign $reviewer (HTTP $HTTP_CODE): $RESPONSE_BODY"
-            fi
-          done
-          
-          # Verify at least one reviewer was assigned
-          echo ""
-          echo "Checking assigned reviewers..."
-          
-          REVIEWERS_RESPONSE=$(curl -s \
-            "https://forge.alexanderwhitestone.com/api/v1/repos/$REPO/pulls/$PR_NUMBER/requested_reviewers" \
-            -H "Authorization: token $GITEA_TOKEN")
-          
-          REVIEWER_COUNT=$(echo "$REVIEWERS_RESPONSE" | jq '.users | length' 2>/dev/null || echo "0")
-          
-          if [ "$REVIEWER_COUNT" -gt 0 ]; then
-            echo "✅ PR #$PR_NUMBER has $REVIEWER_COUNT reviewer(s) assigned"
-            echo "$REVIEWERS_RESPONSE" | jq '.users[].login' 2>/dev/null || echo "$REVIEWERS_RESPONSE"
-          else
-            echo "❌ ERROR: No reviewers assigned to PR #$PR_NUMBER"
-            exit 1
-          fi
-      
-      - name: Add comment about reviewer assignment
-        env:
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          REPO: ${{ github.repository }}
-        run: |
-          # Get assigned reviewers
-          REVIEWERS_RESPONSE=$(curl -s \
-            "https://forge.alexanderwhitestone.com/api/v1/repos/$REPO/pulls/$PR_NUMBER/requested_reviewers" \
-            -H "Authorization: token $GITEA_TOKEN")
-          
-          REVIEWER_LIST=$(echo "$REVIEWERS_RESPONSE" | jq -r '.users[].login' 2>/dev/null | tr '\n' ', ' | sed 's/,$//')
-          
-          if [ -n "$REVIEWER_LIST" ]; then
-            COMMENT="## Automated Reviewer Assignment
-            
-            Reviewers have been automatically assigned to this PR:
-            
-            **Assigned Reviewers:** $REVIEWER_LIST
-            
-            **Policy:** All PRs must have at least one reviewer assigned before merging.
-            
-            **Next Steps:**
-            1. Reviewers will be notified automatically
-            2. Please review the changes within 48 hours
-            3. Request changes or approve as appropriate
-            
-            This is an automated assignment based on CODEOWNERS and repository policy.
-            See issue #1444 for details."
-            
-            # Add comment to PR
-            curl -s -X POST \
-              "https://forge.alexanderwhitestone.com/api/v1/repos/$REPO/issues/$PR_NUMBER/comments" \
-              -H "Authorization: token $GITEA_TOKEN" \
-              -H "Content-Type: application/json" \
-              -d "{\"body\": \"$COMMENT\"}" > /dev/null
-            
-            echo "✅ Added comment about reviewer assignment"
-          fi

.github/CODEOWNERS

@@ -12,8 +12,21 @@ the-nexus/ai/ @Timmy
 timmy-home/ @perplexity
 timmy-config/ @perplexity
 
-# Owner gates for critical systems
+# Owner gates
 hermes-agent/ @Timmy
+# CODEOWNERS - Mandatory Review Policy
 
-# QA reviewer for all PRs
-* @perplexity
+# Default reviewer for all repositories
+* @perplexity
+
+# Specialized component owners
+hermes-agent/ @Timmy
+hermes-agent/agent-core/ @Rockachopa
+hermes-agent/protocol/ @Timmy
+the-nexus/ @perplexity
+the-nexus/ai/ @Timmy
+timmy-home/ @perplexity
+timmy-config/ @perplexity
+
+# Owner gates
+hermes-agent/ @Timmy

bin/check_reviewers.py

@@ -1,241 +0,0 @@
-#!/usr/bin/env python3
-"""
-Check for PRs without assigned reviewers.
-Issue #1444: policy: Implement automated reviewer assignment
-"""
-
-import json
-import os
-import sys
-import urllib.request
-from typing import Dict, List, Any, Optional
-
-# Configuration
-GITEA_BASE = "https://forge.alexanderwhitestone.com/api/v1"
-TOKEN_PATH = os.path.expanduser("~/.config/gitea/token")
-ORG = "Timmy_Foundation"
-
-class ReviewerChecker:
-    def __init__(self):
-        self.token = self._load_token()
-        
-    def _load_token(self) -> str:
-        """Load Gitea API token."""
-        try:
-            with open(TOKEN_PATH, "r") as f:
-                return f.read().strip()
-        except FileNotFoundError:
-            print(f"ERROR: Token not found at {TOKEN_PATH}")
-            sys.exit(1)
-    
-    def _api_request(self, endpoint: str) -> Any:
-        """Make authenticated Gitea API request."""
-        url = f"{GITEA_BASE}{endpoint}"
-        headers = {"Authorization": f"token {self.token}"}
-        
-        req = urllib.request.Request(url, headers=headers)
-        
-        try:
-            with urllib.request.urlopen(req) as resp:
-                return json.loads(resp.read())
-        except urllib.error.HTTPError as e:
-            if e.code == 404:
-                return None
-            error_body = e.read().decode() if e.fp else "No error body"
-            print(f"API Error {e.code}: {error_body}")
-            return None
-    
-    def get_open_prs(self, repo: str) -> List[Dict]:
-        """Get open PRs for a repository."""
-        endpoint = f"/repos/{ORG}/{repo}/pulls?state=open"
-        prs = self._api_request(endpoint)
-        return prs if isinstance(prs, list) else []
-    
-    def get_pr_reviewers(self, repo: str, pr_number: int) -> Dict:
-        """Get requested reviewers for a PR."""
-        endpoint = f"/repos/{ORG}/{repo}/pulls/{pr_number}/requested_reviewers"
-        return self._api_request(endpoint) or {}
-    
-    def get_pr_reviews(self, repo: str, pr_number: int) -> List[Dict]:
-        """Get reviews for a PR."""
-        endpoint = f"/repos/{ORG}/{repo}/pulls/{pr_number}/reviews"
-        reviews = self._api_request(endpoint)
-        return reviews if isinstance(reviews, list) else []
-    
-    def check_prs_without_reviewers(self, repos: List[str]) -> Dict[str, Any]:
-        """Check for PRs without assigned reviewers."""
-        results = {
-            "repos": {},
-            "summary": {
-                "total_prs": 0,
-                "prs_without_reviewers": 0,
-                "repos_checked": len(repos)
-            }
-        }
-        
-        for repo in repos:
-            prs = self.get_open_prs(repo)
-            results["repos"][repo] = {
-                "total_prs": len(prs),
-                "prs_without_reviewers": [],
-                "prs_with_reviewers": []
-            }
-            results["summary"]["total_prs"] += len(prs)
-            
-            for pr in prs:
-                pr_number = pr["number"]
-                pr_title = pr["title"]
-                pr_author = pr["user"]["login"]
-                
-                # Check for requested reviewers
-                requested = self.get_pr_reviewers(repo, pr_number)
-                has_requested = len(requested.get("users", [])) > 0
-                
-                # Check for existing reviews
-                reviews = self.get_pr_reviews(repo, pr_number)
-                has_reviews = len(reviews) > 0
-                
-                # Check if author is the only potential reviewer
-                is_self_review = pr_author in [r.get("user", {}).get("login") for r in reviews]
-                
-                if not has_requested and not has_reviews:
-                    results["repos"][repo]["prs_without_reviewers"].append({
-                        "number": pr_number,
-                        "title": pr_title,
-                        "author": pr_author,
-                        "created": pr["created_at"],
-                        "url": pr["html_url"]
-                    })
-                    results["summary"]["prs_without_reviewers"] += 1
-                else:
-                    results["repos"][repo]["prs_with_reviewers"].append({
-                        "number": pr_number,
-                        "title": pr_title,
-                        "author": pr_author,
-                        "has_requested": has_requested,
-                        "has_reviews": has_reviews,
-                        "is_self_review": is_self_review
-                    })
-        
-        return results
-    
-    def generate_report(self, results: Dict[str, Any]) -> str:
-        """Generate a report of reviewer assignment status."""
-        report = "# PR Reviewer Assignment Report\n\n"
-        report += "## Summary\n"
-        report += f"- **Repositories checked:** {results['summary']['repos_checked']}\n"
-        report += f"- **Total open PRs:** {results['summary']['total_prs']}\n"
-        report += f"- **PRs without reviewers:** {results['summary']['prs_without_reviewers']}\n\n"
-        
-        if results['summary']['prs_without_reviewers'] == 0:
-            report += "✅ **All PRs have assigned reviewers.**\n"
-        else:
-            report += "⚠️ **PRs without assigned reviewers:**\n\n"
-            
-            for repo, data in results["repos"].items():
-                if data["prs_without_reviewers"]:
-                    report += f"### {repo}\n"
-                    for pr in data["prs_without_reviewers"]:
-                        report += f"- **#{pr['number']}**: {pr['title']}\n"
-                        report += f"  - Author: {pr['author']}\n"
-                        report += f"  - Created: {pr['created']}\n"
-                        report += f"  - URL: {pr['url']}\n"
-                    report += "\n"
-        
-        report += "## Repository Details\n\n"
-        for repo, data in results["repos"].items():
-            report += f"### {repo}\n"
-            report += f"- **Total PRs:** {data['total_prs']}\n"
-            report += f"- **PRs without reviewers:** {len(data['prs_without_reviewers'])}\n"
-            report += f"- **PRs with reviewers:** {len(data['prs_with_reviewers'])}\n\n"
-            
-            if data['prs_with_reviewers']:
-                report += "**PRs with reviewers:**\n"
-                for pr in data['prs_with_reviewers']:
-                    status = "✅" if pr['has_requested'] else "⚠️"
-                    if pr['is_self_review']:
-                        status = "⚠️ (self-review)"
-                    report += f"- {status} #{pr['number']}: {pr['title']}\n"
-                report += "\n"
-        
-        return report
-    
-    def assign_reviewer(self, repo: str, pr_number: int, reviewer: str) -> bool:
-        """Assign a reviewer to a PR."""
-        endpoint = f"/repos/{ORG}/{repo}/pulls/{pr_number}/requested_reviewers"
-        data = {"reviewers": [reviewer]}
-        
-        url = f"{GITEA_BASE}{endpoint}"
-        headers = {
-            "Authorization": f"token {self.token}",
-            "Content-Type": "application/json"
-        }
-        
-        req = urllib.request.Request(url, headers=headers, method="POST")
-        req.data = json.dumps(data).encode()
-        
-        try:
-            with urllib.request.urlopen(req) as resp:
-                return resp.status == 201
-        except urllib.error.HTTPError as e:
-            print(f"Failed to assign reviewer: {e.code}")
-            return False
-
-
-def main():
-    """Main entry point for reviewer checker."""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Check for PRs without assigned reviewers")
-    parser.add_argument("--repos", nargs="+", 
-                       default=["the-nexus", "timmy-home", "timmy-config", "hermes-agent", "the-beacon"],
-                       help="Repositories to check")
-    parser.add_argument("--report", action="store_true", help="Generate report")
-    parser.add_argument("--json", action="store_true", help="Output JSON instead of report")
-    parser.add_argument("--assign", nargs=2, metavar=("REPO", "PR"),
-                       help="Assign a reviewer to a specific PR")
-    parser.add_argument("--reviewer", help="Reviewer to assign (e.g., @perplexity)")
-    
-    args = parser.parse_args()
-    
-    checker = ReviewerChecker()
-    
-    if args.assign:
-        # Assign reviewer to specific PR
-        repo, pr_number = args.assign
-        reviewer = args.reviewer or "@perplexity"
-        
-        if checker.assign_reviewer(repo, int(pr_number), reviewer):
-            print(f"✅ Assigned {reviewer} as reviewer to {repo} #{pr_number}")
-        else:
-            print(f"❌ Failed to assign reviewer to {repo} #{pr_number}")
-            sys.exit(1)
-    else:
-        # Check for PRs without reviewers
-        results = checker.check_prs_without_reviewers(args.repos)
-        
-        if args.json:
-            print(json.dumps(results, indent=2))
-        elif args.report:
-            report = checker.generate_report(results)
-            print(report)
-        else:
-            # Default: show summary
-            print(f"Checked {results['summary']['repos_checked']} repositories")
-            print(f"Total open PRs: {results['summary']['total_prs']}")
-            print(f"PRs without reviewers: {results['summary']['prs_without_reviewers']}")
-            
-            if results['summary']['prs_without_reviewers'] > 0:
-                print("\nPRs without reviewers:")
-                for repo, data in results["repos"].items():
-                    if data["prs_without_reviewers"]:
-                        for pr in data["prs_without_reviewers"]:
-                            print(f"  {repo} #{pr['number']}: {pr['title']}")
-                sys.exit(1)
-            else:
-                print("\n✅ All PRs have assigned reviewers")
-                sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

docs/auto-reviewer-assignment.md

@@ -1,227 +0,0 @@
-# Automated Reviewer Assignment
-
-**Issue:** #1444 - policy: Implement automated reviewer assignment (from Issue #1127 triage)  
-**Purpose:** Ensure all PRs have at least one reviewer assigned
-
-## Problem
-
-From issue #1127 triage:
-> "0 of 14 PRs had a reviewer assigned before this pass."
-
-This means:
-- PRs can be created without any reviewer
-- No automated enforcement of reviewer assignment
-- PRs may sit without review for extended periods
-
-## Solution
-
-### 1. GitHub Actions Workflow (`.gitea/workflows/auto-assign-reviewers.yml`)
-Automatically assigns reviewers when PRs are created:
-
-**When it runs:**
-- On PR open
-- On PR reopen
-- On PR ready for review (not draft)
-
-**What it does:**
-1. Determines appropriate reviewers based on repository
-2. Assigns reviewers via Gitea API
-3. Adds comment about reviewer assignment
-4. Verifies at least one reviewer is assigned
-
-### 2. Reviewer Check Script (`bin/check_reviewers.py`)
-Script to check for PRs without reviewers:
-
-**Usage:**
-```bash
-# Check all repositories
-python bin/check_reviewers.py
-
-# Check specific repositories
-python bin/check_reviewers.py --repos the-nexus timmy-home
-
-# Generate report
-python bin/check_reviewers.py --report
-
-# Assign reviewer to specific PR
-python bin/check_reviewers.py --assign the-nexus 123 --reviewer @perplexity
-```
-
-### 3. CODEOWNERS File (`.github/CODEOWNERS`)
-Defines default reviewers for different paths:
-
-```
-# Default reviewer for all repositories
-* @perplexity
-
-# Specialized component owners
-hermes-agent/ @Timmy
-hermes-agent/agent-core/ @Rockachopa
-hermes-agent/protocol/ @Timmy
-the-nexus/ @perplexity
-the-nexus/ai/ @Timmy
-timmy-home/ @perplexity
-timmy-config/ @perplexity
-
-# Owner gates for critical systems
-hermes-agent/ @Timmy
-```
-
-## Reviewer Assignment Rules
-
-### Repository-Specific Rules
-
-| Repository | Default Reviewers | Required Reviewers | Notes |
-|------------|-------------------|-------------------|-------|
-| hermes-agent | @Timmy, @perplexity | @Timmy | Owner gate for critical system |
-| the-nexus | @perplexity | None | QA gate |
-| timmy-home | @perplexity | None | QA gate |
-| timmy-config | @perplexity | None | QA gate |
-| the-beacon | @perplexity | None | QA gate |
-
-### Special Rules
-
-1. **No self-review:** PR author cannot be assigned as reviewer
-2. **Fallback:** If no reviewers available, assign @perplexity
-3. **Critical systems:** hermes-agent requires @Timmy as reviewer
-
-## How It Works
-
-### Automated Assignment Flow
-
-1. **PR Created** → GitHub Actions workflow triggers
-2. **Determine Reviewers** → Based on repository and CODEOWNERS
-3. **Assign Reviewers** → Via Gitea API
-4. **Add Comment** → Notify about assignment
-5. **Verify** → Ensure at least one reviewer assigned
-
-### Manual Assignment
-
-```bash
-# Assign specific reviewer
-python bin/check_reviewers.py --assign the-nexus 123 --reviewer @perplexity
-
-# Check for PRs without reviewers
-python bin/check_reviewers.py --report
-```
-
-## Configuration
-
-### Environment Variables
-
-- `GITEA_TOKEN`: Gitea API token for authentication
-- `REPO`: Repository name (auto-set in GitHub Actions)
-- `PR_NUMBER`: PR number (auto-set in GitHub Actions)
-
-### Repository Configuration
-
-Edit the workflow to customize reviewer assignment:
-
-```yaml
-# Define default reviewers based on repository
-case "$REPO_NAME" in
-  "hermes-agent")
-    DEFAULT_REVIEWERS=("Timmy" "perplexity")
-    REQUIRED_REVIEWERS=("Timmy")
-    ;;
-  "the-nexus")
-    DEFAULT_REVIEWERS=("perplexity")
-    REQUIRED_REVIEWERS=()
-    ;;
-  # Add more repositories as needed
-esac
-```
-
-## Testing
-
-### Test the workflow:
-
-1. Create a test PR
-2. Check if reviewers are automatically assigned
-3. Verify comment is added
-
-### Test the script:
-
-```bash
-# Check for PRs without reviewers
-python bin/check_reviewers.py --report
-
-# Assign reviewer to test PR
-python bin/check_reviewers.py --assign the-nexus 123 --reviewer @perplexity
-```
-
-## Monitoring
-
-### Check for PRs without reviewers:
-
-```bash
-# Daily check
-python bin/check_reviewers.py --report
-
-# JSON output for automation
-python bin/check_reviewers.py --json
-```
-
-### Review assignment logs:
-
-1. Check GitHub Actions logs for assignment details
-2. Review PR comments for assignment notifications
-3. Monitor for PRs with 0 reviewers
-
-## Enforcement
-
-### CI Check (Future Enhancement)
-
-Add CI check to reject PRs with 0 reviewers:
-
-```yaml
-# In CI workflow
-- name: Check for reviewers
-  run: |
-    REVIEWERS=$(curl -s "https://forge.alexanderwhitestone.com/api/v1/repos/$REPO/pulls/$PR_NUMBER/requested_reviewers" \
-      -H "Authorization: token $GITEA_TOKEN" | jq '.users | length')
-    
-    if [ "$REVIEWERS" -eq 0 ]; then
-      echo "❌ ERROR: PR has no reviewers assigned"
-      exit 1
-    fi
-```
-
-### Policy Enforcement
-
-1. **All PRs must have reviewers** - No exceptions
-2. **No self-review** - PR author cannot review own PR
-3. **Critical systems require specific reviewers** - hermes-agent requires @Timmy
-
-## Related Issues
-
-- **Issue #1127:** Perplexity Evening Pass triage (identified missing reviewers)
-- **Issue #1444:** This implementation
-- **Issue #1336:** Merge conflicts in CODEOWNERS (fixed)
-
-## Files Added/Modified
-
-1. `.gitea/workflows/auto-assign-reviewers.yml` - GitHub Actions workflow
-2. `bin/check_reviewers.py` - Reviewer check script
-3. `.github/CODEOWNERS` - Cleaned up CODEOWNERS file
-4. `docs/auto-reviewer-assignment.md` - This documentation
-
-## Future Enhancements
-
-1. **CI check for 0 reviewers** - Reject PRs without reviewers
-2. **Slack/Telegram notifications** - Notify when PRs lack reviewers
-3. **Load balancing** - Distribute reviews evenly among team members
-4. **Auto-assign based on file changes** - Assign specialists for specific areas
-
-## Conclusion
-
-This implementation ensures all PRs have at least one reviewer assigned:
-- **Automated assignment** on PR creation
-- **Manual checking** for existing PRs
-- **Clear documentation** of policies and procedures
-
-**Result:** No more PRs sitting without reviewers.
-
-## License
-
-Part of the Timmy Foundation project.

nexus/evennia_ws_bridge.py

@@ -28,11 +28,16 @@ except ImportError:
     websockets = None
 
 from nexus.evennia_event_adapter import (
+    actor_located,
     audit_heartbeat,
     command_executed,
+    command_issued,
+    command_result,
     player_join,
     player_leave,
     player_move,
+    room_snapshot,
+    session_bound,
 )
 
 ANSI_RE = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
@@ -49,31 +54,82 @@ def strip_ansi(text: str) -> str:
     return ANSI_RE.sub("", text or "")
 
 
+def clean_lines(text: str) -> list[str]:
+    """Strip ANSI codes and split into non-empty lines."""
+    text = strip_ansi(text).replace("\r", "")
+    return [line.strip() for line in text.split("\n") if line.strip()]
+
+
+def parse_room_output(text: str) -> dict | None:
+    """Parse Evennia room output into structured data with title, desc, exits, objects."""
+    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().replace(" and ", ", ")
+            exits = [{"key": t.strip(), "destination_id": t.strip().title(), "destination_key": t.strip().title()} for t in raw.split(",") if t.strip()]
+        elif line.startswith("You see:"):
+            raw = line.split(":", 1)[1].strip().replace(" and ", ", ")
+            parts = [t.strip() for t in raw.split(",") if t.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]:
+    """Normalize a raw Evennia event dict into a list of Nexus event dicts."""
+    out = []
+    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))
+    elif 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
+
+
 class LogTailer:
     """Async file tailer that yields new lines as they appear."""
-    
+
     def __init__(self, path: str, poll_interval: float = 0.5):
         self.path = path
         self.poll_interval = poll_interval
         self._offset = 0
-    
+
     async def tail(self):
         """Yield new lines from the file, starting from end."""
         # Start at end of file
         if os.path.exists(self.path):
             self._offset = os.path.getsize(self.path)
-        
+
         while True:
             try:
                 if not os.path.exists(self.path):
                     await asyncio.sleep(self.poll_interval)
                     continue
-                
+
                 size = os.path.getsize(self.path)
                 if size < self._offset:
                     # File was truncated/rotated
                     self._offset = 0
-                
+
                 if size > self._offset:
                     with open(self.path, "r") as f:
                         f.seek(self._offset)
@@ -82,7 +138,7 @@ class LogTailer:
                             if line:
                                 yield line
                         self._offset = f.tell()
-                
+
                 await asyncio.sleep(self.poll_interval)
             except Exception as e:
                 print(f"[tailer] Error reading {self.path}: {e}", flush=True)
@@ -91,44 +147,44 @@ class LogTailer:
 
 def parse_log_line(line: str) -> Optional[dict]:
     """Parse a log line into a Nexus event, or None if not parseable."""
-    
+
     # Movement events
     m = MOVE_RE.search(line)
     if m:
         return player_move(m.group(1), m.group(3), m.group(2))
-    
+
     # Command events
     m = CMD_RE.search(line)
     if m:
         return command_executed(m.group(1), m.group(2), m.group(3) or "")
-    
+
     # Session start
     m = SESSION_START_RE.search(line)
     if m:
         return player_join(m.group(2), m.group(1))
-    
+
     # Session end
     m = SESSION_END_RE.search(line)
     if m:
         return player_leave("", m.group(1), session_duration=float(m.group(2)))
-    
+
     # Server login
     m = LOGIN_RE.search(line)
     if m:
         return player_join(m.group(1), ip_address=m.group(2))
-    
+
     # Server logout
     m = LOGOUT_RE.search(line)
     if m:
         return player_leave(m.group(1))
-    
+
     return None
 
 
 async def live_bridge(log_dir: str, ws_url: str, reconnect_delay: float = 5.0):
     """
     Main live bridge loop.
-    
+
     Tails all Evennia log files and streams parsed events to Nexus WebSocket.
     Auto-reconnects on failure.
     """
@@ -138,9 +194,9 @@ async def live_bridge(log_dir: str, ws_url: str, reconnect_delay: float = 5.0):
         os.path.join(log_dir, "player_activity.log"),
         os.path.join(log_dir, "server.log"),
     ]
-    
+
     event_queue: asyncio.Queue = asyncio.Queue(maxsize=10000)
-    
+
     async def tail_file(path: str):
         """Tail a single file and put events on queue."""
         tailer = LogTailer(path)
@@ -151,7 +207,7 @@ async def live_bridge(log_dir: str, ws_url: str, reconnect_delay: float = 5.0):
                     event_queue.put_nowait(event)
                 except asyncio.QueueFull:
                     pass  # Drop oldest if queue full
-    
+
     async def ws_sender():
         """Send events from queue to WebSocket, with auto-reconnect."""
         while True:
@@ -162,7 +218,7 @@ async def live_bridge(log_dir: str, ws_url: str, reconnect_delay: float = 5.0):
                         event = await event_queue.get()
                         ts = event.get("timestamp", "")[:19]
                         print(f"[{ts}] {event['type']}: {json.dumps({k: v for k, v in event.items() if k not in ('type', 'timestamp')})}", flush=True)
-                
+
                 print(f"[bridge] Connecting to {ws_url}...", flush=True)
                 async with websockets.connect(ws_url) as ws:
                     print(f"[bridge] Connected to Nexus at {ws_url}", flush=True)
@@ -172,67 +228,17 @@ async def live_bridge(log_dir: str, ws_url: str, reconnect_delay: float = 5.0):
             except Exception as e:
                 print(f"[bridge] WebSocket error: {e}. Reconnecting in {reconnect_delay}s...", flush=True)
                 await asyncio.sleep(reconnect_delay)
-    
+
     # Start all tailers + sender
     tasks = [asyncio.create_task(tail_file(f)) for f in log_files]
     tasks.append(asyncio.create_task(ws_sender()))
-    
+
     print(f"[bridge] Live bridge started. Watching {len(log_files)} log files.", flush=True)
     await asyncio.gather(*tasks)
 
 
 async def playback(log_path: Path, ws_url: str):
     """Legacy mode: replay a telemetry JSONL file."""
-    from nexus.evennia_event_adapter import (
-        actor_located, command_issued, command_result,
-        room_snapshot, session_bound,
-    )
-    
-    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().replace(" and ", ", ")
-                exits = [{"key": t.strip(), "destination_id": t.strip().title(), "destination_key": t.strip().title()} for t in raw.split(",") if t.strip()]
-            elif line.startswith("You see:"):
-                raw = line.split(":", 1)[1].strip().replace(" and ", ", ")
-                parts = [t.strip() for t in raw.split(",") if t.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 = []
-        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))
-        elif 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
-    
     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():
@@ -245,11 +251,6 @@ async def playback(log_path: Path, ws_url: str):
 
 async def inject_event(event_type: str, ws_url: str, **kwargs):
     """Inject a single Evennia event into the Nexus WS gateway. Dev/test use."""
-    from nexus.evennia_event_adapter import (
-        actor_located, command_issued, command_result,
-        room_snapshot, session_bound,
-    )
-
     builders = {
         "room_snapshot": lambda: room_snapshot(
             kwargs.get("room_key", "Gate"),