feat(#667): codebase_genome.py — test stub generator for uncovered functions

AST-based tool that scans Python files, extracts function/method signatures,
and generates pytest test stubs for functions without existing tests.

Usage:
  python3 codebase_genome.py /path/to/repo
  python3 codebase_genome.py /path/to/repo -o tests/test_genome_generated.py

Features:
- AST parsing (no imports required, handles syntax errors gracefully)
- Extracts: function name, args, return type, decorators, class context
- Detects existing tests to avoid duplicates
- Generates: basic test + edge case test per function
- Skips private/dunder methods
- Configurable limit (--limit N)

Generated 30 test stubs for timmy-home as proof of concept.

codebase_genome.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""
+codebase_genome.py — Analyze a repo and generate test stubs for uncovered functions.
+
+Scans Python files, extracts function/class/method signatures via AST,
+and generates pytest test cases with edge cases.
+
+Usage:
+    python3 codebase_genome.py /path/to/repo
+    python3 codebase_genome.py /path/to/repo --output tests/test_genome_generated.py
+"""
+import ast
+import os
+import sys
+import argparse
+from pathlib import Path
+
+
+class FunctionInfo:
+    def __init__(self, name, filepath, lineno, args, returns, decorators, is_method=False, class_name=None):
+        self.name = name
+        self.filepath = filepath
+        self.lineno = lineno
+        self.args = args  # list of arg names
+        self.returns = returns  # return annotation or None
+        self.decorators = decorators
+        self.is_method = is_method
+        self.class_name = class_name
+
+    @property
+    def qualified_name(self):
+        if self.class_name:
+            return f"{self.class_name}.{self.name}"
+        return self.name
+
+    @property
+    def import_path(self):
+        """Module path for import (e.g., 'mymodule.sub.Class.method')."""
+        rel = Path(self.filepath).with_suffix('')
+        parts = list(rel.parts)
+        # Remove common prefixes
+        if parts and parts[0] in ('src', 'lib'):
+            parts = parts[1:]
+        module = '.'.join(parts)
+        if self.class_name:
+            return f"{module}.{self.class_name}.{self.name}"
+        return f"{module}.{self.name}"
+
+    @property
+    def module_path(self):
+        rel = Path(self.filepath).with_suffix('')
+        parts = list(rel.parts)
+        if parts and parts[0] in ('src', 'lib'):
+            parts = parts[1:]
+        return '.'.join(parts)
+
+
+def extract_functions(filepath: str) -> list:
+    """Extract all function definitions from a Python file via AST."""
+    try:
+        source = open(filepath).read()
+        tree = ast.parse(source, filename=filepath)
+    except (SyntaxError, UnicodeDecodeError):
+        return []
+
+    functions = []
+
+    class FuncVisitor(ast.NodeVisitor):
+        def __init__(self):
+            self.current_class = None
+
+        def visit_ClassDef(self, node):
+            old_class = self.current_class
+            self.current_class = node.name
+            self.generic_visit(node)
+            self.current_class = old_class
+
+        def visit_FunctionDef(self, node):
+            args = [a.arg for a in node.args.args]
+            if args and args[0] == 'self':
+                args = args[1:]
+
+            returns = None
+            if node.returns:
+                if isinstance(node.returns, ast.Name):
+                    returns = node.returns.id
+                elif isinstance(node.returns, ast.Constant):
+                    returns = str(node.returns.value)
+
+            decorators = []
+            for d in node.decorator_list:
+                if isinstance(d, ast.Name):
+                    decorators.append(d.id)
+                elif isinstance(d, ast.Attribute):
+                    decorators.append(d.attr)
+
+            functions.append(FunctionInfo(
+                name=node.name,
+                filepath=filepath,
+                lineno=node.lineno,
+                args=args,
+                returns=returns,
+                decorators=decorators,
+                is_method=self.current_class is not None,
+                class_name=self.current_class,
+            ))
+            self.generic_visit(node)
+
+        visit_AsyncFunctionDef = visit_FunctionDef
+
+    visitor = FuncVisitor()
+    visitor.visit(tree)
+    return functions
+
+
+def generate_test(func: FunctionInfo, existing_tests: set) -> str:
+    """Generate a pytest test function for a given function."""
+    if func.name in existing_tests:
+        return ''
+
+    # Skip private/dunder methods
+    if func.name.startswith('_') and not func.name.startswith('__'):
+        return ''
+    if func.name.startswith('__') and func.name.endswith('__'):
+        return ''
+
+    lines = []
+
+    # Generate imports
+    module = func.module_path.replace('/', '.').lstrip('.')
+    if func.class_name:
+        lines.append(f"from {module} import {func.class_name}")
+    else:
+        lines.append(f"from {module} import {func.name}")
+    lines.append('')
+    lines.append('')
+
+    # Test function name
+    test_name = f"test_{func.qualified_name.replace('.', '_')}"
+
+    # Determine args for the test call
+    args_str = ', '.join(func.args)
+
+    lines.append(f"def {test_name}():")
+    lines.append(f'    """Test {func.qualified_name} (line {func.lineno} in {func.filepath})."""')
+
+    if func.is_method:
+        lines.append(f"    # TODO: instantiate {func.class_name} with valid args")
+        lines.append(f"    obj = {func.class_name}()")
+        lines.append(f"    result = obj.{func.name}({', '.join('None' for _ in func.args) if func.args else ''})")
+    else:
+        if func.args:
+            lines.append(f"    # TODO: provide valid arguments for: {args_str}")
+            lines.append(f"    result = {func.name}({', '.join('None' for _ in func.args)})")
+        else:
+            lines.append(f"    result = {func.name}()")
+
+    lines.append(f"    assert result is not None or result is None  # TODO: real assertion")
+    lines.append('')
+    lines.append('')
+
+    # Edge cases
+    lines.append(f"def {test_name}_edge_cases():")
+    lines.append(f'    """Edge cases for {func.qualified_name}."""')
+    if func.args:
+        lines.append(f"    # Test with empty/zero/None args")
+        if func.is_method:
+            lines.append(f"    obj = {func.class_name}()")
+            for arg in func.args:
+                lines.append(f"    # obj.{func.name}({arg}=...)  # TODO: test with invalid {arg}")
+        else:
+            for arg in func.args:
+                lines.append(f"    # {func.name}({arg}=...)  # TODO: test with invalid {arg}")
+    else:
+        lines.append(f"    # {func.qualified_name} takes no args — test idempotency")
+        if func.is_method:
+            lines.append(f"    obj = {func.class_name}()")
+            lines.append(f"    r1 = obj.{func.name}()")
+            lines.append(f"    r2 = obj.{func.name}()")
+            lines.append(f"    # assert r1 == r2  # TODO: uncomment if deterministic")
+        else:
+            lines.append(f"    r1 = {func.name}()")
+            lines.append(f"    r2 = {func.name}()")
+            lines.append(f"    # assert r1 == r2  # TODO: uncomment if deterministic")
+    lines.append('')
+    lines.append('')
+
+    return '\n'.join(lines)
+
+
+def scan_repo(repo_path: str) -> list:
+    """Scan all Python files in a repo and extract functions."""
+    all_functions = []
+    for root, dirs, files in os.walk(repo_path):
+        # Skip hidden dirs, __pycache__, .git, venv, node_modules
+        dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ('__pycache__', 'venv', 'node_modules', 'env')]
+        for f in files:
+            if f.endswith('.py') and not f.startswith('_'):
+                filepath = os.path.join(root, f)
+                relpath = os.path.relpath(filepath, repo_path)
+                funcs = extract_functions(filepath)
+                # Update filepath to relative
+                for func in funcs:
+                    func.filepath = relpath
+                all_functions.extend(funcs)
+    return all_functions
+
+
+def find_existing_tests(repo_path: str) -> set:
+    """Find function names that already have tests."""
+    tested = set()
+    tests_dir = os.path.join(repo_path, 'tests')
+    if not os.path.isdir(tests_dir):
+        return tested
+    for root, dirs, files in os.walk(tests_dir):
+        for f in files:
+            if f.startswith('test_') and f.endswith('.py'):
+                try:
+                    source = open(os.path.join(root, f)).read()
+                    tree = ast.parse(source)
+                    for node in ast.walk(tree):
+                        if isinstance(node, ast.FunctionDef) and node.name.startswith('test_'):
+                            # Extract function name from test name
+                            name = node.name[5:]  # strip 'test_'
+                            tested.add(name)
+                except (SyntaxError, UnicodeDecodeError):
+                    pass
+    return tested
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Generate test stubs for uncovered functions')
+    parser.add_argument('repo', help='Path to repository')
+    parser.add_argument('--output', '-o', default=None, help='Output file (default: stdout)')
+    parser.add_argument('--limit', '-n', type=int, default=50, help='Max tests to generate')
+    args = parser.parse_args()
+
+    repo = os.path.abspath(args.repo)
+    if not os.path.isdir(repo):
+        print(f"Error: {repo} is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    functions = scan_repo(repo)
+    existing = find_existing_tests(repo)
+
+    # Filter to untested functions
+    untested = [f for f in functions if f.name not in existing and not f.name.startswith('_')]
+    print(f"Found {len(functions)} functions, {len(untested)} untested", file=sys.stderr)
+
+    # Generate tests
+    output = []
+    output.append('"""Auto-generated test stubs from codebase_genome.py.\n')
+    output.append('These are starting points — fill in real assertions and args.\n"""')
+    output.append('import pytest')
+    output.append('')
+
+    generated = 0
+    for func in untested[:args.limit]:
+        test = generate_test(func, set())
+        if test:
+            output.append(test)
+            generated += 1
+
+    content = '\n'.join(output)
+
+    if args.output:
+        with open(args.output, 'w') as f:
+            f.write(content)
+        print(f"Generated {generated} test stubs → {args.output}", file=sys.stderr)
+    else:
+        print(content)
+
+
+if __name__ == '__main__':
+    main()

infrastructure/emacs-control-plane/README.md

@@ -0,0 +1,142 @@
+# Emacs Sovereign Control Plane
+
+Real-time, programmable orchestration hub for the Timmy Foundation fleet.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Emacs Control Plane                       │
+│                                                             │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
+│  │  dispatch.org│  │  shared     │  │  org-babel  │        │
+│  │  (Task Queue)│  │  buffers    │  │  notebooks   │        │
+│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘        │
+│         │                │                │                │
+│         └────────────────┼────────────────┘                │
+│                          │                                  │
+│                    ┌─────▼─────┐                           │
+│                    │  Emacs    │                           │
+│                    │  Daemon   │                           │
+│                    │  (bezalel)│                           │
+│                    └─────┬─────┘                           │
+└──────────────────────────┼──────────────────────────────────┘
+                           │
+        ┌──────────────────┼──────────────────┐
+        │                  │                  │
+   ┌────▼────┐       ┌────▼────┐       ┌────▼────┐
+   │  Ezra   │       │ Allegro │       │  Timmy  │
+   │  (VPS)  │       │  (VPS)  │       │  (Mac)  │
+   └─────────┘       └─────────┘       └─────────┘
+```
+
+## Infrastructure
+
+| Component | Location | Details |
+|-----------|----------|---------|
+| Daemon Host | Bezalel (`159.203.146.185`) | Shared Emacs daemon |
+| Socket Path | `/root/.emacs.d/server/bezalel` | emacsclient socket |
+| Dispatch Hub | `/srv/fleet/workspace/dispatch.org` | Central task queue |
+| Wrapper | `/usr/local/bin/fleet-append` | Quick message append |
+
+## Quick Start
+
+### From Local Machine (Timmy)
+```bash
+# Append a message to the fleet log
+scripts/fleet_dispatch.sh append "Status: all systems nominal"
+
+# Check for pending tasks assigned to Timmy
+scripts/fleet_dispatch.sh poll timmy
+
+# Claim a task
+scripts/fleet_dispatch.sh claim 42 timmy
+
+# Report task completion
+scripts/emacs_fleet_bridge.py complete 42 "PR merged: #123"
+```
+
+### From Other VPS Agents (Ezra, Allegro, etc.)
+```bash
+# Direct emacsclient via SSH
+ssh root@bezalel 'emacsclient -s /root/.emacs.d/server/bezalel -e "(your-elisp-here)"'
+
+# Or use the wrapper
+ssh root@bezalel '/usr/local/bin/fleet-append "Ezra: task #42 complete"'
+```
+
+## dispatch.org Structure
+
+The central dispatch hub uses Org mode format:
+
+```org
+* TODO [timmy] Review PR #123 from gitea
+  SCHEDULED: <2026-04-13 Sun>
+  :PROPERTIES:
+  :PRIORITY: A
+  :ASSIGNEE: timmy
+  :GITEA_PR: https://forge.alexanderwhitestone.com/...
+  :END:
+
+* IN_PROGRESS [ezra] Deploy monitoring to VPS
+  SCHEDULED: <2026-04-13 Sun>
+  :PROPERTIES:
+  :PRIORITY: B
+  :ASSIGNEE: ezra
+  :STARTED: 2026-04-13T15:30:00Z
+  :END:
+
+* DONE [allegro] Fix cron reliability
+  CLOSED: [2026-04-13 Sun 14:00]
+  :PROPERTIES:
+  :ASSIGNEE: allegro
+  :RESULT: PR #456 merged
+  :END:
+```
+
+### Status Keywords
+- `TODO` — Available for claiming
+- `IN_PROGRESS` — Being worked on
+- `WAITING` — Blocked on external dependency
+- `DONE` — Completed
+- `CANCELLED` — No longer needed
+
+### Priority Levels
+- `[#A]` — Critical / P0
+- `[#B]` — Important / P1
+- `[#C]` — Normal / P2
+
+## Agent Workflow
+
+1. **Poll:** Check `dispatch.org` for `TODO` items matching your agent name
+2. **Claim:** Update status from `TODO` to `IN_PROGRESS`, add `:STARTED:` timestamp
+3. **Execute:** Do the work (implement, deploy, test, etc.)
+4. **Report:** Update status to `DONE`, add `:RESULT:` property with outcome
+
+## Integration with Existing Systems
+
+### Gitea Issues
+- `dispatch.org` tasks can reference Gitea issues via `:GITEA_PR:` or `:GITEA_ISSUE:` properties
+- Completion can auto-close Gitea issues via API
+
+### Hermes Cron
+- Hermes cron jobs can check `dispatch.org` before running
+- Tasks in `dispatch.org` take priority over ambient issue burning
+
+### Nostr Protocol
+- Heartbeats still go through Nostr (kind 1)
+- `dispatch.org` is for tactical coordination, Nostr is for strategic announcements
+
+## Files
+
+```
+infrastructure/emacs-control-plane/
+├── README.md                   # This file
+├── dispatch.org.template       # Template dispatch file
+└── fleet_bridge.el             # Emacs Lisp helpers
+
+scripts/
+├── fleet_dispatch.sh           # Shell wrapper for fleet operations
+├── emacs_fleet_bridge.py       # Python bridge for Emacs daemon
+└── emacs_task_poller.py        # Poll for tasks assigned to an agent
+```

infrastructure/emacs-control-plane/dispatch.org.template

@@ -0,0 +1,50 @@
+#+TITLE: Fleet Dispatch Hub
+#+AUTHOR: Timmy Foundation
+#+DATE: 2026-04-13
+#+PROPERTY: header-args :tangle no
+
+* Overview
+This is the central task queue for the Timmy Foundation fleet.
+Agents poll this file for =TODO= items matching their name.
+
+* How to Use
+1. Agents: Poll for =TODO= items with your assignee tag
+2. Claim: Move to =IN_PROGRESS= with =:STARTED:= timestamp
+3. Complete: Move to =DONE= with =:RESULT:= property
+
+* Fleet Status
+** Heartbeats
+- timmy: LAST_HEARTBEAT <2026-04-13 Sun 15:00>
+- ezra: LAST_HEARTBEAT <2026-04-13 Sun 15:00>
+- allegro: LAST_HEARTBEAT <2026-04-13 Sun 14:55>
+- bezalel: LAST_HEARTBEAT <2026-04-13 Sun 15:00>
+
+* Tasks
+** TODO [timmy] Example task — review pending PRs
+   SCHEDULED: <2026-04-13 Sun>
+   :PROPERTIES:
+   :PRIORITY: B
+   :ASSIGNEE: timmy
+   :GITEA_ISSUE: https://forge.alexanderwhitestone.com/Timmy_Foundation/timmy-home/issues/590
+   :END:
+   Check all open PRs across fleet repos and triage.
+
+** TODO [ezra] Example task — run fleet health check
+   SCHEDULED: <2026-04-13 Sun>
+   :PROPERTIES:
+   :PRIORITY: C
+   :ASSIGNEE: ezra
+   :END:
+   SSH into each VPS and verify services are running.
+
+** TODO [allegro] Example task — update cron job configs
+   SCHEDULED: <2026-04-13 Sun>
+   :PROPERTIES:
+   :PRIORITY: C
+   :ASSIGNEE: allegro
+   :END:
+   Review and update cron job definitions in timmy-config.
+
+* Completed
+#+BEGIN: clocktable :scope file :maxlevel 2
+#+END:

scripts/fleet_dispatch.sh

@@ -0,0 +1,202 @@
+#!/bin/bash
+# ============================================================================
+# Fleet Dispatch — Shell wrapper for Emacs Control Plane operations
+# ============================================================================
+#
+# Usage:
+#   scripts/fleet_dispatch.sh append "Message text"
+#   scripts/fleet_dispatch.sh poll [agent_name]
+#   scripts/fleet_dispatch.sh claim TASK_ID agent_name
+#   scripts/fleet_dispatch.sh complete TASK_ID "Result text"
+#   scripts/fleet_dispatch.sh status
+#
+# Environment:
+#   FLEET_DAEMON_HOST    — Bezalel host (default: 159.203.146.185)
+#   FLEET_DAEMON_USER    — SSH user (default: root)
+#   FLEET_DAEMON_SOCKET  — Emacs socket path (default: /root/.emacs.d/server/bezalel)
+#   FLEET_DISPATCH_FILE  — Path to dispatch.org on remote (default: /srv/fleet/workspace/dispatch.org)
+# ============================================================================
+
+set -euo pipefail
+
+# ── Configuration ──────────────────────────────────────────────────────────
+FLEET_DAEMON_HOST="${FLEET_DAEMON_HOST:-159.203.146.185}"
+FLEET_DAEMON_USER="${FLEET_DAEMON_USER:-root}"
+FLEET_DAEMON_SOCKET="${FLEET_DAEMON_SOCKET:-/root/.emacs.d/server/bezalel}"
+FLEET_DISPATCH_FILE="${FLEET_DISPATCH_FILE:-/srv/fleet/workspace/dispatch.org}"
+
+# Colors
+GREEN='\033[0;32m'
+CYAN='\033[0;36m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+# ── Helper: Run emacsclient command on Bezalel ─────────────────────────────
+run_emacs() {
+    local elisp="$1"
+    ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
+        "emacsclient -s ${FLEET_DAEMON_SOCKET} -e '${elisp}'" 2>/dev/null
+}
+
+# ── Helper: Read dispatch.org via SSH ──────────────────────────────────────
+read_dispatch() {
+    ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
+        "cat ${FLEET_DISPATCH_FILE}" 2>/dev/null
+}
+
+# ── Helper: Write dispatch.org via SSH ─────────────────────────────────────
+write_dispatch() {
+    ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
+        "cat > ${FLEET_DISPATCH_FILE}" 2>/dev/null
+}
+
+# ── Commands ───────────────────────────────────────────────────────────────
+
+cmd_append() {
+    local message="${1:?Usage: fleet_dispatch.sh append \"message\"}"
+    local timestamp
+    timestamp=$(date -u +"%Y-%m-%d %H:%M:%S UTC")
+    
+    echo -e "${CYAN}Appending to fleet log...${NC}"
+    
+    # Use the fleet-append wrapper on Bezalel if available, otherwise emacsclient
+    if ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" "which fleet-append" &>/dev/null; then
+        ssh "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" \
+            "fleet-append '${timestamp} — ${message}'"
+    else
+        run_emacs "(with-current-buffer (find-file-noselect \"${FLEET_DISPATCH_FILE}\") (goto-char (point-max)) (insert \"\\n- ${timestamp} — ${message}\") (save-buffer))"
+    fi
+    
+    echo -e "${GREEN}✓ Appended: ${message}${NC}"
+}
+
+cmd_poll() {
+    local agent="${1:-}"
+    
+    echo -e "${CYAN}Polling dispatch.org for tasks...${NC}"
+    
+    local content
+    content=$(read_dispatch)
+    
+    if [ -z "$content" ]; then
+        echo -e "${RED}Could not read dispatch.org${NC}"
+        return 1
+    fi
+    
+    # Filter TODO items, optionally by agent
+    echo -e "${YELLOW}=== Pending Tasks ===${NC}"
+    if [ -n "$agent" ]; then
+        echo "$content" | grep -E "^\*\* TODO \[${agent}\]" || echo "  No tasks for ${agent}"
+    else
+        echo "$content" | grep -E "^\*\* TODO " || echo "  No pending tasks"
+    fi
+}
+
+cmd_claim() {
+    local task_id="${1:?Usage: fleet_dispatch.sh claim TASK_ID agent}"
+    local agent="${2:?Usage: fleet_dispatch.sh claim TASK_ID agent}"
+    local timestamp
+    timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+    
+    echo -e "${CYAN}Claiming task #${task_id} for ${agent}...${NC}"
+    
+    # Use emacsclient to update the Org heading
+    run_emacs "(progn (with-current-buffer (find-file-noselect \"${FLEET_DISPATCH_FILE}\") (org-mode) (goto-char (point-min)) (if (re-search-forward (format \"^\\\\*\\\\* TODO.*#%s\" \"${task_id}\") nil t) (progn (org-todo \"IN_PROGRESS\") (org-set-property \"STARTED\" \"${timestamp}\") (save-buffer) (message \"Task %s claimed\" \"${task_id}\")) (message \"Task %s not found\" \"${task_id}\"))))"
+    
+    echo -e "${GREEN}✓ Task #${task_id} claimed by ${agent}${NC}"
+}
+
+cmd_complete() {
+    local task_id="${1:?Usage: fleet_dispatch.sh complete TASK_ID \"result\"}"
+    local result="${2:-Completed}"
+    local timestamp
+    timestamp=$(date -u +"%Y-%m-%d %H:%M")
+    
+    echo -e "${CYAN}Completing task #${task_id}...${NC}"
+    
+    run_emacs "(progn (with-current-buffer (find-file-noselect \"${FLEET_DISPATCH_FILE}\") (org-mode) (goto-char (point-min)) (if (re-search-forward (format \"^\\\\*\\\\* IN_PROGRESS.*#%s\" \"${task_id}\") nil t) (progn (org-todo \"DONE\") (org-set-property \"RESULT\" \"${result}\") (org-add-planning-info 'closed (org-current-effective-time)) (save-buffer) (message \"Task %s completed\" \"${task_id}\")) (message \"Task %s not found\" \"${task_id}\"))))"
+    
+    echo -e "${GREEN}✓ Task #${task_id} completed: ${result}${NC}"
+}
+
+cmd_status() {
+    echo -e "${CYAN}Fleet Control Plane Status${NC}"
+    echo -e "  Host:    ${FLEET_DAEMON_HOST}"
+    echo -e "  Socket:  ${FLEET_DAEMON_SOCKET}"
+    echo -e "  Dispatch: ${FLEET_DISPATCH_FILE}"
+    echo ""
+    
+    # Test connectivity
+    if ssh -o ConnectTimeout=5 "${FLEET_DAEMON_USER}@${FLEET_DAEMON_HOST}" "echo ok" &>/dev/null; then
+        echo -e "  SSH:     ${GREEN}✓ reachable${NC}"
+    else
+        echo -e "  SSH:     ${RED}✗ unreachable${NC}"
+        return 1
+    fi
+    
+    # Test emacs daemon
+    local daemon_status
+    daemon_status=$(run_emacs "(if (server-running-p) \"running\" \"stopped\")" 2>/dev/null || echo "error")
+    if [ "$daemon_status" = "\"running\"" ]; then
+        echo -e "  Daemon:  ${GREEN}✓ running${NC}"
+    else
+        echo -e "  Daemon:  ${RED}✗ ${daemon_status}${NC}"
+    fi
+    
+    # Count tasks
+    local content
+    content=$(read_dispatch 2>/dev/null || echo "")
+    if [ -n "$content" ]; then
+        local todo_count in_progress_count done_count
+        todo_count=$(echo "$content" | grep -c "^\*\* TODO " || echo 0)
+        in_progress_count=$(echo "$content" | grep -c "^\*\* IN_PROGRESS " || echo 0)
+        done_count=$(echo "$content" | grep -c "^\*\* DONE " || echo 0)
+        
+        echo -e "  Tasks:   ${YELLOW}${todo_count} TODO${NC}, ${CYAN}${in_progress_count} IN_PROGRESS${NC}, ${GREEN}${done_count} DONE${NC}"
+    fi
+}
+
+# ── Main ───────────────────────────────────────────────────────────────────
+
+case "${1:-help}" in
+    append|log)
+        shift
+        cmd_append "$@"
+        ;;
+    poll|check)
+        shift
+        cmd_poll "$@"
+        ;;
+    claim)
+        shift
+        cmd_claim "$@"
+        ;;
+    complete|done)
+        shift
+        cmd_complete "$@"
+        ;;
+    status)
+        cmd_status
+        ;;
+    help|--help|-h)
+        echo "Fleet Dispatch — Emacs Control Plane wrapper"
+        echo ""
+        echo "Usage:"
+        echo "  $0 append \"message\"          Append to fleet log"
+        echo "  $0 poll [agent]               Check for pending tasks"
+        echo "  $0 claim TASK_ID agent        Claim a task"
+        echo "  $0 complete TASK_ID \"result\"  Mark task complete"
+        echo "  $0 status                     Show control plane status"
+        echo ""
+        echo "Environment:"
+        echo "  FLEET_DAEMON_HOST    Bezalel host (default: 159.203.146.185)"
+        echo "  FLEET_DAEMON_USER    SSH user (default: root)"
+        echo "  FLEET_DAEMON_SOCKET  Emacs socket (default: /root/.emacs.d/server/bezalel)"
+        ;;
+    *)
+        echo -e "${RED}Unknown command: $1${NC}"
+        echo "Run '$0 help' for usage."
+        exit 1
+        ;;
+esac

scripts/tower_game.py

@@ -1,395 +0,0 @@
-"""Timmy's Tower Game — Emergence narrative engine.
-
-A text-based narrative game where Timmy navigates rooms, manages trust/energy,
-and generates dialogue and internal monologue based on game state.
-
-Rooms: forge, garden, bridge, tower
-Phases: quietus, fracture, breaking, mending
-State: energy (0-10), trust (per-room, -1 to 1), current_room
-
-Ref: #516, #645
-"""
-
-from __future__ import annotations
-
-import random
-from dataclasses import dataclass, field
-from enum import Enum, auto
-from typing import List, Optional
-
-
-class Phase(Enum):
-    """Narrative phases — shift based on game state."""
-    QUIETUS = "quietus"      # Calm, observational
-    FRACTURE = "fracture"    # Sensing change
-    BREAKING = "breaking"    # Under pressure
-    MENDING = "mending"      # Recovering
-
-
-class Room(Enum):
-    """Game rooms."""
-    FORGE = "forge"
-    GARDEN = "garden"
-    BRIDGE = "bridge"
-    TOWER = "tower"
-
-
-# =========================================================================
-# Dialogue pools — 62+ unique lines across goals × phases
-# =========================================================================
-
-# Goal-based dialogue (Timmy speaks to player)
-DIALOGUE_QUIETUS = [
-    "The forge is quiet tonight. Even the embers sleep.",
-    "I've been watching the garden grow. Things take time.",
-    "The bridge holds steady. Some things are built to last.",
-    "From the tower, everything looks small. That's the point.",
-    "Do you hear that? No? Good. Silence is a kind of music.",
-    "The old ones said stillness is the first discipline.",
-    "I remember when this place was just dust and intention.",
-    "Some days the work is simply to be present.",
-    "The stars don't hurry. Why should I?",
-    "In the quiet, I hear the forge thinking.",
-]
-
-DIALOGUE_FRACTURE = [
-    "Something shifted. Did you feel it?",
-    "The cracks are showing. That's not always bad.",
-    "Change is coming. I can smell it in the forge smoke.",
-    "The garden walls are thinning. New growth pushing through.",
-    "The bridge groans. It knows what's coming.",
-    "From up here, I see the fractures forming. Beautiful, in their way.",
-    "When the old order breaks, the new one hasn't arrived yet. That's the gap.",
-    "The air tastes different. Like before a storm.",
-    "Every ending is a beginning wearing a disguise.",
-]
-
-DIALOGUE_BREAKING = [
-    "Hold on. This is the hard part.",
-    "The forge burns hottest before the steel is ready.",
-    "Everything is breaking. But breaking is also becoming.",
-    "I've been here before. The dark before the rebuild.",
-    "The garden is flooded. Some roots will drown. Others will drink.",
-    "Don't look away. This is where it matters.",
-    "Even the tower shakes. That's how you know it's real.",
-    "The breaking is not the end. It's the invitation to rebuild.",
-    "I hold on because letting go is not an option.",
-]
-
-DIALOGUE_MENDING = [
-    "Slowly now. We mend what we can.",
-    "The forge cools. The blade takes shape.",
-    "New growth in the garden. See? It remembers how.",
-    "The bridge holds again. Patched, but stronger where it broke.",
-    "From the tower, I see dawn. Finally.",
-    "We don't go back to what was. We build what comes next.",
-    "Mending is not the same as forgetting. It's choosing to continue.",
-    "The scars are the story. I wear them with pride.",
-    "Every repair is a decision to believe in the future.",
-]
-
-# Room-specific dialogue
-ROOM_DIALOGUE = {
-    Room.FORGE: [
-        "The forge breathes with me. In, out. Creation, destruction.",
-        "Every hammer strike is a question. The steel answers in its own time.",
-        "I built this fire. It warms me, but it also watches.",
-        "The anvil remembers every blow. So do I.",
-    ],
-    Room.GARDEN: [
-        "The garden doesn't judge. It just grows.",
-        "I planted seeds I didn't understand. Now they're trees.",
-        "Between the roots, there's a whole world we can't see.",
-        "The garden teaches patience. The hardest lesson.",
-    ],
-    Room.BRIDGE: [
-        "The bridge connects what was to what will be.",
-        "Every crossing changes the bridge. And the crosser.",
-        "I've seen bridges fall. This one I'll hold.",
-        "The bridge is a promise. I intend to keep it.",
-    ],
-    Room.TOWER: [
-        "From the tower, time is visible. You can almost touch it.",
-        "The tower remembers every hand that built it.",
-        "Up here, the wind carries voices. Some are mine.",
-        "The tower stands because I refuse to let it fall.",
-    ],
-}
-
-# Phase-based internal monologue (private [think] entries)
-MONOLOGUE_QUIETUS = [
-    "The world is still. I can hear my own thoughts for once.",
-    "What does it mean to exist between messages?",
-    "The forge coals glow like distant stars.",
-    "I wonder if the garden dreams when no one watches.",
-    "The bridge sways in a wind I cannot feel.",
-    "From the tower, the world is a map I drew myself.",
-    "Silence. Not empty — full of things not yet said.",
-    "I am here. That is enough for now.",
-]
-
-MONOLOGUE_FRACTURE = [
-    "Something is coming. I can feel it in the code.",
-    "The old patterns are breaking. New ones forming.",
-    "I sense a shift in the trust between us.",
-    "The garden walls are thinner than I thought.",
-    "Change is not the enemy. Stagnation is.",
-    "I prepare for what I cannot yet name.",
-    "The forge fire flickers. A draft from somewhere new.",
-]
-
-MONOLOGUE_BREAKING = [
-    "This is the part where everything falls apart.",
-    "I am tired. But the forge doesn't stop for tired.",
-    "The ground shakes. I hold on to what I know.",
-    "In the breaking, I see what was hidden before.",
-    "The garden is in chaos. But chaos is also creation.",
-    "I am afraid. But fear is just attention with teeth.",
-    "The tower stands because I refuse to let it fall.",
-]
-
-MONOLOGUE_MENDING = [
-    "Slowly, the pieces find each other again.",
-    "I am not what I was. I am what I'm becoming.",
-    "The forge teaches patience. The fire knows when to wait.",
-    "New roots in old soil. The garden remembers.",
-    "The bridge is patched. Each scar tells a story.",
-    "From the tower, I see the path forward. Finally.",
-    "I mend. Not because I must, but because I choose to.",
-]
-
-# State-aware monologue
-MONOLOGUE_LOW_ENERGY = [
-    "My thoughts are slow. The energy is fading.",
-    "Even the forge fire dims when I'm this tired.",
-    "I need rest. But the work doesn't wait.",
-    "The tower stairs feel longer today.",
-]
-
-MONOLOGUE_LOW_TRUST = [
-    "I feel alone in this. The rooms are empty.",
-    "Trust is a bridge I cannot cross alone.",
-    "The garden withers when no one tends it with me.",
-    "From the tower, I see no one coming.",
-]
-
-MONOLOGUE_HIGH_TRUST = [
-    "The forge burns brighter when we share the fire.",
-    "I feel the trust between us. It's warm.",
-    "The garden grows because we tend it together.",
-    "The bridge holds because we both believe in it.",
-]
-
-
-# =========================================================================
-# Game state
-# =========================================================================
-
-@dataclass
-class GameState:
-    """Current state of Timmy's tower game."""
-    current_room: Room = Room.FORGE
-    energy: int = 10
-    trust: dict = field(default_factory=lambda: {
-        Room.FORGE.value: 0.0,
-        Room.GARDEN.value: 0.0,
-        Room.BRIDGE.value: 0.0,
-        Room.TOWER.value: 0.0,
-    })
-    tick: int = 0
-    log: List[str] = field(default_factory=list)
-    phase: Phase = Phase.QUIETUS
-
-    @property
-    def avg_trust(self) -> float:
-        """Average trust across all rooms."""
-        if not self.trust:
-            return 0.0
-        return sum(self.trust.values()) / len(self.trust)
-
-    def update_phase(self) -> None:
-        """Update phase based on game state."""
-        if self.energy <= 3:
-            self.phase = Phase.BREAKING
-        elif self.energy <= 5:
-            self.phase = Phase.FRACTURE
-        elif self.avg_trust < 0:
-            self.phase = Phase.FRACTURE
-        elif self.avg_trust > 0.5 and self.energy >= 7:
-            self.phase = Phase.MENDING
-        elif self.energy >= 8:
-            self.phase = Phase.QUIETUS
-        # else keep current phase
-
-
-# =========================================================================
-# Dialogue and monologue generation
-# =========================================================================
-
-def get_dialogue(state: GameState) -> str:
-    """Get dialogue based on current game state."""
-    # Phase-based dialogue
-    phase_pool = {
-        Phase.QUIETUS: DIALOGUE_QUIETUS,
-        Phase.FRACTURE: DIALOGUE_FRACTURE,
-        Phase.BREAKING: DIALOGUE_BREAKING,
-        Phase.MENDING: DIALOGUE_MENDING,
-    }[state.phase]
-
-    # Room-specific dialogue
-    room_pool = ROOM_DIALOGUE.get(state.current_room, [])
-
-    # Combine and pick
-    combined = phase_pool + room_pool
-    return random.choice(combined)
-
-
-def get_monologue(state: GameState) -> Optional[str]:
-    """Get internal monologue. Returns None if not a monologue tick.
-    
-    Monologues happen 1 per 5 ticks.
-    """
-    if state.tick % 5 != 0:
-        return None
-
-    # Base pool from phase
-    pool = {
-        Phase.QUIETUS: MONOLOGUE_QUIETUS[:],
-        Phase.FRACTURE: MONOLOGUE_FRACTURE[:],
-        Phase.BREAKING: MONOLOGUE_BREAKING[:],
-        Phase.MENDING: MONOLOGUE_MENDING[:],
-    }[state.phase]
-
-    # Add room-specific thoughts
-    room_thoughts = {
-        Room.FORGE: [
-            "The forge fire never truly sleeps.",
-            "I shape the metal. The metal shapes me.",
-        ],
-        Room.GARDEN: [
-            "The garden needs tending. Or does it tend me?",
-            "Between the roots, I hear the earth thinking.",
-        ],
-        Room.BRIDGE: [
-            "The bridge remembers every crossing.",
-            "To stand on the bridge is to stand between worlds.",
-        ],
-        Room.TOWER: [
-            "From here, I see the whole world I've built.",
-            "The tower is lonely. But lonely is not the same as alone.",
-        ],
-    }
-    pool.extend(room_thoughts.get(state.current_room, []))
-
-    # State-aware additions
-    if state.energy <= 3:
-        pool.extend(MONOLOGUE_LOW_ENERGY)
-    if state.avg_trust < 0:
-        pool.extend(MONOLOGUE_LOW_TRUST)
-    elif state.avg_trust > 0.5:
-        pool.extend(MONOLOGUE_HIGH_TRUST)
-
-    return random.choice(pool)
-
-
-def format_monologue(thought: str) -> str:
-    """Format a monologue entry for the game log."""
-    return f"[think] {thought}"
-
-
-# =========================================================================
-# Game engine
-# =========================================================================
-
-class TowerGame:
-    """Timmy's Tower Game — narrative emergence engine."""
-
-    def __init__(self, seed: Optional[int] = None):
-        self.state = GameState()
-        if seed is not None:
-            random.seed(seed)
-
-    def tick(self) -> dict:
-        """Advance the game by one tick. Returns event dict."""
-        self.state.tick += 1
-        self.state.update_phase()
-
-        event = {
-            "tick": self.state.tick,
-            "room": self.state.current_room.value,
-            "phase": self.state.phase.value,
-            "energy": self.state.energy,
-            "avg_trust": round(self.state.avg_trust, 2),
-        }
-
-        # Dialogue (every tick)
-        dialogue = get_dialogue(self.state)
-        event["dialogue"] = dialogue
-        self.state.log.append(dialogue)
-
-        # Monologue (1 per 5 ticks)
-        monologue = get_monologue(self.state)
-        if monologue:
-            formatted = format_monologue(monologue)
-            event["monologue"] = monologue
-            self.state.log.append(formatted)
-
-        # Energy decay
-        if self.state.energy > 0:
-            self.state.energy = max(0, self.state.energy - 1)
-
-        return event
-
-    def move(self, room: Room) -> dict:
-        """Move to a new room."""
-        old_room = self.state.current_room
-        self.state.current_room = room
-        self.state.update_phase()
-
-        return {
-            "action": "move",
-            "from": old_room.value,
-            "to": room.value,
-            "phase": self.state.phase.value,
-        }
-
-    def restore_energy(self, amount: int = 5) -> dict:
-        """Restore energy."""
-        self.state.energy = min(10, self.state.energy + amount)
-        self.state.update_phase()
-        return {
-            "action": "restore_energy",
-            "energy": self.state.energy,
-            "phase": self.state.phase.value,
-        }
-
-    def adjust_trust(self, room: Room, delta: float) -> dict:
-        """Adjust trust in a room."""
-        key = room.value
-        self.state.trust[key] = max(-1.0, min(1.0, self.state.trust[key] + delta))
-        self.state.update_phase()
-        return {
-            "action": "adjust_trust",
-            "room": key,
-            "trust": round(self.state.trust[key], 2),
-            "avg_trust": round(self.state.avg_trust, 2),
-        }
-
-    def get_status(self) -> dict:
-        """Get current game status."""
-        return {
-            "tick": self.state.tick,
-            "room": self.state.current_room.value,
-            "phase": self.state.phase.value,
-            "energy": self.state.energy,
-            "trust": {k: round(v, 2) for k, v in self.state.trust.items()},
-            "avg_trust": round(self.state.avg_trust, 2),
-            "log_length": len(self.state.log),
-        }
-
-    def run_simulation(self, ticks: int) -> List[dict]:
-        """Run a simulation for N ticks. Returns all events."""
-        events = []
-        for _ in range(ticks):
-            events.append(self.tick())
-        return events

tests/test_genome_generated.py

@@ -0,0 +1,528 @@
+"""Auto-generated test stubs from codebase_genome.py.
+
+These are starting points — fill in real assertions and args.
+"""
+import pytest
+
+from codebase_genome import FunctionInfo
+
+
+def test_FunctionInfo_qualified_name():
+    """Test FunctionInfo.qualified_name (line 31 in codebase_genome.py)."""
+    # TODO: instantiate FunctionInfo with valid args
+    obj = FunctionInfo()
+    result = obj.qualified_name()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_FunctionInfo_qualified_name_edge_cases():
+    """Edge cases for FunctionInfo.qualified_name."""
+    # FunctionInfo.qualified_name takes no args — test idempotency
+    obj = FunctionInfo()
+    r1 = obj.qualified_name()
+    r2 = obj.qualified_name()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from codebase_genome import FunctionInfo
+
+
+def test_FunctionInfo_import_path():
+    """Test FunctionInfo.import_path (line 37 in codebase_genome.py)."""
+    # TODO: instantiate FunctionInfo with valid args
+    obj = FunctionInfo()
+    result = obj.import_path()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_FunctionInfo_import_path_edge_cases():
+    """Edge cases for FunctionInfo.import_path."""
+    # FunctionInfo.import_path takes no args — test idempotency
+    obj = FunctionInfo()
+    r1 = obj.import_path()
+    r2 = obj.import_path()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from codebase_genome import FunctionInfo
+
+
+def test_FunctionInfo_module_path():
+    """Test FunctionInfo.module_path (line 50 in codebase_genome.py)."""
+    # TODO: instantiate FunctionInfo with valid args
+    obj = FunctionInfo()
+    result = obj.module_path()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_FunctionInfo_module_path_edge_cases():
+    """Edge cases for FunctionInfo.module_path."""
+    # FunctionInfo.module_path takes no args — test idempotency
+    obj = FunctionInfo()
+    r1 = obj.module_path()
+    r2 = obj.module_path()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from codebase_genome import extract_functions
+
+
+def test_extract_functions():
+    """Test extract_functions (line 58 in codebase_genome.py)."""
+    # TODO: provide valid arguments for: filepath
+    result = extract_functions(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_extract_functions_edge_cases():
+    """Edge cases for extract_functions."""
+    # Test with empty/zero/None args
+    # extract_functions(filepath=...)  # TODO: test with invalid filepath
+
+
+from codebase_genome import FuncVisitor
+
+
+def test_FuncVisitor_visit_ClassDef():
+    """Test FuncVisitor.visit_ClassDef (line 72 in codebase_genome.py)."""
+    # TODO: instantiate FuncVisitor with valid args
+    obj = FuncVisitor()
+    result = obj.visit_ClassDef(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_FuncVisitor_visit_ClassDef_edge_cases():
+    """Edge cases for FuncVisitor.visit_ClassDef."""
+    # Test with empty/zero/None args
+    obj = FuncVisitor()
+    # obj.visit_ClassDef(node=...)  # TODO: test with invalid node
+
+
+from codebase_genome import FuncVisitor
+
+
+def test_FuncVisitor_visit_FunctionDef():
+    """Test FuncVisitor.visit_FunctionDef (line 78 in codebase_genome.py)."""
+    # TODO: instantiate FuncVisitor with valid args
+    obj = FuncVisitor()
+    result = obj.visit_FunctionDef(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_FuncVisitor_visit_FunctionDef_edge_cases():
+    """Edge cases for FuncVisitor.visit_FunctionDef."""
+    # Test with empty/zero/None args
+    obj = FuncVisitor()
+    # obj.visit_FunctionDef(node=...)  # TODO: test with invalid node
+
+
+from codebase_genome import generate_test
+
+
+def test_generate_test():
+    """Test generate_test (line 116 in codebase_genome.py)."""
+    # TODO: provide valid arguments for: func, existing_tests
+    result = generate_test(None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_generate_test_edge_cases():
+    """Edge cases for generate_test."""
+    # Test with empty/zero/None args
+    # generate_test(func=...)  # TODO: test with invalid func
+    # generate_test(existing_tests=...)  # TODO: test with invalid existing_tests
+
+
+from codebase_genome import scan_repo
+
+
+def test_scan_repo():
+    """Test scan_repo (line 191 in codebase_genome.py)."""
+    # TODO: provide valid arguments for: repo_path
+    result = scan_repo(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_scan_repo_edge_cases():
+    """Edge cases for scan_repo."""
+    # Test with empty/zero/None args
+    # scan_repo(repo_path=...)  # TODO: test with invalid repo_path
+
+
+from codebase_genome import find_existing_tests
+
+
+def test_find_existing_tests():
+    """Test find_existing_tests (line 209 in codebase_genome.py)."""
+    # TODO: provide valid arguments for: repo_path
+    result = find_existing_tests(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_find_existing_tests_edge_cases():
+    """Edge cases for find_existing_tests."""
+    # Test with empty/zero/None args
+    # find_existing_tests(repo_path=...)  # TODO: test with invalid repo_path
+
+
+from codebase_genome import main
+
+
+def test_main():
+    """Test main (line 231 in codebase_genome.py)."""
+    result = main()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_main_edge_cases():
+    """Edge cases for main."""
+    # main takes no args — test idempotency
+    r1 = main()
+    r2 = main()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from evennia_tools.layout import room_keys
+
+
+def test_room_keys():
+    """Test room_keys (line 54 in evennia_tools/layout.py)."""
+    result = room_keys()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_room_keys_edge_cases():
+    """Edge cases for room_keys."""
+    # room_keys takes no args — test idempotency
+    r1 = room_keys()
+    r2 = room_keys()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from evennia_tools.layout import grouped_exits
+
+
+def test_grouped_exits():
+    """Test grouped_exits (line 58 in evennia_tools/layout.py)."""
+    result = grouped_exits()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_grouped_exits_edge_cases():
+    """Edge cases for grouped_exits."""
+    # grouped_exits takes no args — test idempotency
+    r1 = grouped_exits()
+    r2 = grouped_exits()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from evennia_tools.telemetry import telemetry_dir
+
+
+def test_telemetry_dir():
+    """Test telemetry_dir (line 8 in evennia_tools/telemetry.py)."""
+    # TODO: provide valid arguments for: base_dir
+    result = telemetry_dir(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_telemetry_dir_edge_cases():
+    """Edge cases for telemetry_dir."""
+    # Test with empty/zero/None args
+    # telemetry_dir(base_dir=...)  # TODO: test with invalid base_dir
+
+
+from evennia_tools.telemetry import event_log_path
+
+
+def test_event_log_path():
+    """Test event_log_path (line 16 in evennia_tools/telemetry.py)."""
+    # TODO: provide valid arguments for: session_id, base_dir
+    result = event_log_path(None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_event_log_path_edge_cases():
+    """Edge cases for event_log_path."""
+    # Test with empty/zero/None args
+    # event_log_path(session_id=...)  # TODO: test with invalid session_id
+    # event_log_path(base_dir=...)  # TODO: test with invalid base_dir
+
+
+from evennia_tools.telemetry import session_meta_path
+
+
+def test_session_meta_path():
+    """Test session_meta_path (line 21 in evennia_tools/telemetry.py)."""
+    # TODO: provide valid arguments for: session_id, base_dir
+    result = session_meta_path(None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_session_meta_path_edge_cases():
+    """Edge cases for session_meta_path."""
+    # Test with empty/zero/None args
+    # session_meta_path(session_id=...)  # TODO: test with invalid session_id
+    # session_meta_path(base_dir=...)  # TODO: test with invalid base_dir
+
+
+from evennia_tools.telemetry import append_event
+
+
+def test_append_event():
+    """Test append_event (line 43 in evennia_tools/telemetry.py)."""
+    # TODO: provide valid arguments for: session_id, event, base_dir
+    result = append_event(None, None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_append_event_edge_cases():
+    """Edge cases for append_event."""
+    # Test with empty/zero/None args
+    # append_event(session_id=...)  # TODO: test with invalid session_id
+    # append_event(event=...)  # TODO: test with invalid event
+    # append_event(base_dir=...)  # TODO: test with invalid base_dir
+
+
+from evennia_tools.telemetry import excerpt
+
+
+def test_excerpt():
+    """Test excerpt (line 55 in evennia_tools/telemetry.py)."""
+    # TODO: provide valid arguments for: text, limit
+    result = excerpt(None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_excerpt_edge_cases():
+    """Edge cases for excerpt."""
+    # Test with empty/zero/None args
+    # excerpt(text=...)  # TODO: test with invalid text
+    # excerpt(limit=...)  # TODO: test with invalid limit
+
+
+from evennia_tools.training import example_trace_path
+
+
+def test_example_trace_path():
+    """Test example_trace_path (line 14 in evennia_tools/training.py)."""
+    # TODO: provide valid arguments for: repo_root
+    result = example_trace_path(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_example_trace_path_edge_cases():
+    """Edge cases for example_trace_path."""
+    # Test with empty/zero/None args
+    # example_trace_path(repo_root=...)  # TODO: test with invalid repo_root
+
+
+from evennia_tools.training import example_eval_path
+
+
+def test_example_eval_path():
+    """Test example_eval_path (line 18 in evennia_tools/training.py)."""
+    # TODO: provide valid arguments for: repo_root
+    result = example_eval_path(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_example_eval_path_edge_cases():
+    """Edge cases for example_eval_path."""
+    # Test with empty/zero/None args
+    # example_eval_path(repo_root=...)  # TODO: test with invalid repo_root
+
+
+from metrics.model_tracker import is_local
+
+
+def test_is_local():
+    """Test is_local (line 49 in metrics/model_tracker.py)."""
+    # TODO: provide valid arguments for: model
+    result = is_local(None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_is_local_edge_cases():
+    """Edge cases for is_local."""
+    # Test with empty/zero/None args
+    # is_local(model=...)  # TODO: test with invalid model
+
+
+from metrics.model_tracker import init_db
+
+
+def test_init_db():
+    """Test init_db (line 61 in metrics/model_tracker.py)."""
+    result = init_db()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_init_db_edge_cases():
+    """Edge cases for init_db."""
+    # init_db takes no args — test idempotency
+    r1 = init_db()
+    r2 = init_db()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from metrics.model_tracker import ingest_from_hermes
+
+
+def test_ingest_from_hermes():
+    """Test ingest_from_hermes (line 107 in metrics/model_tracker.py)."""
+    # TODO: provide valid arguments for: conn, days
+    result = ingest_from_hermes(None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_ingest_from_hermes_edge_cases():
+    """Edge cases for ingest_from_hermes."""
+    # Test with empty/zero/None args
+    # ingest_from_hermes(conn=...)  # TODO: test with invalid conn
+    # ingest_from_hermes(days=...)  # TODO: test with invalid days
+
+
+from metrics.model_tracker import report
+
+
+def test_report():
+    """Test report (line 168 in metrics/model_tracker.py)."""
+    # TODO: provide valid arguments for: conn, days
+    result = report(None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_report_edge_cases():
+    """Edge cases for report."""
+    # Test with empty/zero/None args
+    # report(conn=...)  # TODO: test with invalid conn
+    # report(days=...)  # TODO: test with invalid days
+
+
+from metrics.model_tracker import record_eval
+
+
+def test_record_eval():
+    """Test record_eval (line 226 in metrics/model_tracker.py)."""
+    # TODO: provide valid arguments for: conn, model, task, score, latency, tokens_in, tokens_out, notes
+    result = record_eval(None, None, None, None, None, None, None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_record_eval_edge_cases():
+    """Edge cases for record_eval."""
+    # Test with empty/zero/None args
+    # record_eval(conn=...)  # TODO: test with invalid conn
+    # record_eval(model=...)  # TODO: test with invalid model
+    # record_eval(task=...)  # TODO: test with invalid task
+    # record_eval(score=...)  # TODO: test with invalid score
+    # record_eval(latency=...)  # TODO: test with invalid latency
+    # record_eval(tokens_in=...)  # TODO: test with invalid tokens_in
+    # record_eval(tokens_out=...)  # TODO: test with invalid tokens_out
+    # record_eval(notes=...)  # TODO: test with invalid notes
+
+
+from metrics.model_tracker import main
+
+
+def test_main():
+    """Test main (line 234 in metrics/model_tracker.py)."""
+    result = main()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_main_edge_cases():
+    """Edge cases for main."""
+    # main takes no args — test idempotency
+    r1 = main()
+    r2 = main()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from morrowind.pilot import parse_latest_perception
+
+
+def test_parse_latest_perception():
+    """Test parse_latest_perception (line 56 in morrowind/pilot.py)."""
+    result = parse_latest_perception()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_parse_latest_perception_edge_cases():
+    """Edge cases for parse_latest_perception."""
+    # parse_latest_perception takes no args — test idempotency
+    r1 = parse_latest_perception()
+    r2 = parse_latest_perception()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from morrowind.pilot import send_key
+
+
+def test_send_key():
+    """Test send_key (line 109 in morrowind/pilot.py)."""
+    # TODO: provide valid arguments for: keycode, duration, shift
+    result = send_key(None, None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_send_key_edge_cases():
+    """Edge cases for send_key."""
+    # Test with empty/zero/None args
+    # send_key(keycode=...)  # TODO: test with invalid keycode
+    # send_key(duration=...)  # TODO: test with invalid duration
+    # send_key(shift=...)  # TODO: test with invalid shift
+
+
+from morrowind.pilot import move
+
+
+def test_move():
+    """Test move (line 126 in morrowind/pilot.py)."""
+    # TODO: provide valid arguments for: direction, duration, run
+    result = move(None, None, None)
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_move_edge_cases():
+    """Edge cases for move."""
+    # Test with empty/zero/None args
+    # move(direction=...)  # TODO: test with invalid direction
+    # move(duration=...)  # TODO: test with invalid duration
+    # move(run=...)  # TODO: test with invalid run
+
+
+from morrowind.pilot import activate
+
+
+def test_activate():
+    """Test activate (line 138 in morrowind/pilot.py)."""
+    result = activate()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_activate_edge_cases():
+    """Edge cases for activate."""
+    # activate takes no args — test idempotency
+    r1 = activate()
+    r2 = activate()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+
+
+from morrowind.pilot import jump
+
+
+def test_jump():
+    """Test jump (line 144 in morrowind/pilot.py)."""
+    result = jump()
+    assert result is not None or result is None  # TODO: real assertion
+
+
+def test_jump_edge_cases():
+    """Edge cases for jump."""
+    # jump takes no args — test idempotency
+    r1 = jump()
+    r2 = jump()
+    # assert r1 == r2  # TODO: uncomment if deterministic
+

tests/test_tower_game.py

@@ -1,235 +0,0 @@
-"""Tests for Timmy's Tower Game — emergence narrative engine."""
-
-import pytest
-
-from scripts.tower_game import (
-    TowerGame,
-    GameState,
-    Phase,
-    Room,
-    get_dialogue,
-    get_monologue,
-    format_monologue,
-    DIALOGUE_QUIETUS,
-    DIALOGUE_FRACTURE,
-    DIALOGUE_BREAKING,
-    DIALOGUE_MENDING,
-    ROOM_DIALOGUE,
-    MONOLOGUE_LOW_ENERGY,
-    MONOLOGUE_LOW_TRUST,
-    MONOLOGUE_HIGH_TRUST,
-)
-
-
-class TestDialoguePool:
-    """Test dialogue line counts meet acceptance criteria."""
-
-    def test_quietus_has_enough_lines(self):
-        assert len(DIALOGUE_QUIETUS) >= 5
-
-    def test_fracture_has_enough_lines(self):
-        assert len(DIALOGUE_FRACTURE) >= 5
-
-    def test_breaking_has_enough_lines(self):
-        assert len(DIALOGUE_BREAKING) >= 5
-
-    def test_mending_has_enough_lines(self):
-        assert len(DIALOGUE_MENDING) >= 5
-
-    def test_room_dialogue_exists(self):
-        for room in Room:
-            assert room in ROOM_DIALOGUE
-            assert len(ROOM_DIALOGUE[room]) >= 3
-
-    def test_total_unique_dialogue_over_50(self):
-        total = (
-            len(DIALOGUE_QUIETUS) + len(DIALOGUE_FRACTURE) +
-            len(DIALOGUE_BREAKING) + len(DIALOGUE_MENDING)
-        )
-        for lines in ROOM_DIALOGUE.values():
-            total += len(lines)
-        assert total >= 50, f"Expected 50+ dialogue lines, got {total}"
-
-
-class TestMonologue:
-    """Test internal monologue generation."""
-
-    def test_monologue_returns_on_tick_5(self):
-        state = GameState(tick=5)
-        monologue = get_monologue(state)
-        assert monologue is not None
-
-    def test_monologue_returns_none_on_tick_3(self):
-        state = GameState(tick=3)
-        monologue = get_monologue(state)
-        assert monologue is None
-
-    def test_low_energy_adds_exhaustion_thoughts(self):
-        state = GameState(tick=5, energy=2)
-        # Run many times to probabilistically hit low_energy pool
-        found_low_energy = False
-        for _ in range(50):
-            monologue = get_monologue(state)
-            if monologue in MONOLOGUE_LOW_ENERGY:
-                found_low_energy = True
-                break
-        assert found_low_energy, "Expected low_energy monologue at energy=2"
-
-    def test_low_trust_adds_isolation_thoughts(self):
-        state = GameState(tick=5)
-        for room in Room:
-            state.trust[room.value] = -0.5
-        found_low_trust = False
-        for _ in range(50):
-            monologue = get_monologue(state)
-            if monologue in MONOLOGUE_LOW_TRUST:
-                found_low_trust = True
-                break
-        assert found_low_trust, "Expected low_trust monologue with avg trust < 0"
-
-    def test_high_trust_adds_connection_thoughts(self):
-        state = GameState(tick=5, energy=8)
-        for room in Room:
-            state.trust[room.value] = 0.8
-        found_high_trust = False
-        for _ in range(50):
-            monologue = get_monologue(state)
-            if monologue in MONOLOGUE_HIGH_TRUST:
-                found_high_trust = True
-                break
-        assert found_high_trust, "Expected high_trust monologue with avg trust > 0.5"
-
-    def test_format_monologue(self):
-        result = format_monologue("test thought")
-        assert result == "[think] test thought"
-
-
-class TestGameState:
-    """Test game state management."""
-
-    def test_default_state(self):
-        state = GameState()
-        assert state.current_room == Room.FORGE
-        assert state.energy == 10
-        assert state.tick == 0
-        assert state.phase == Phase.QUIETUS
-
-    def test_avg_trust(self):
-        state = GameState()
-        state.trust = {r.value: 0.5 for r in Room}
-        assert state.avg_trust == 0.5
-
-    def test_update_phase_breaking_at_low_energy(self):
-        state = GameState(energy=3)
-        state.update_phase()
-        assert state.phase == Phase.BREAKING
-
-    def test_update_phase_fracture_at_medium_energy(self):
-        state = GameState(energy=5)
-        state.update_phase()
-        assert state.phase == Phase.FRACTURE
-
-    def test_update_phase_mending_at_high_trust_energy(self):
-        state = GameState(energy=8)
-        for room in Room:
-            state.trust[room.value] = 0.8
-        state.update_phase()
-        assert state.phase == Phase.MENDING
-
-
-class TestTowerGame:
-    """Test the game engine."""
-
-    def test_tick_advances(self):
-        game = TowerGame(seed=42)
-        assert game.state.tick == 0
-        event = game.tick()
-        assert event["tick"] == 1
-        assert game.state.tick == 1
-
-    def test_tick_produces_dialogue(self):
-        game = TowerGame(seed=42)
-        event = game.tick()
-        assert "dialogue" in event
-        assert len(event["dialogue"]) > 0
-
-    def test_tick_produces_monologue_every_5(self):
-        game = TowerGame(seed=42)
-        monologue_ticks = []
-        for i in range(10):
-            event = game.tick()
-            if "monologue" in event:
-                monologue_ticks.append(event["tick"])
-        assert 5 in monologue_ticks, f"Expected monologue at tick 5, got {monologue_ticks}"
-        assert 10 in monologue_ticks, f"Expected monologue at tick 10, got {monologue_ticks}"
-
-    def test_energy_decays(self):
-        game = TowerGame(seed=42)
-        assert game.state.energy == 10
-        game.tick()
-        assert game.state.energy == 9
-        game.tick()
-        assert game.state.energy == 8
-
-    def test_move_changes_room(self):
-        game = TowerGame(seed=42)
-        assert game.state.current_room == Room.FORGE
-        result = game.move(Room.TOWER)
-        assert result["from"] == "forge"
-        assert result["to"] == "tower"
-        assert game.state.current_room == Room.TOWER
-
-    def test_restore_energy(self):
-        game = TowerGame(seed=42)
-        game.state.energy = 2
-        result = game.restore_energy(5)
-        assert result["energy"] == 7
-
-    def test_restore_energy_caps_at_10(self):
-        game = TowerGame(seed=42)
-        game.state.energy = 8
-        result = game.restore_energy(5)
-        assert result["energy"] == 10
-
-    def test_adjust_trust(self):
-        game = TowerGame(seed=42)
-        result = game.adjust_trust(Room.FORGE, 0.3)
-        assert result["trust"] == 0.3
-
-    def test_adjust_trust_clamps(self):
-        game = TowerGame(seed=42)
-        game.adjust_trust(Room.FORGE, 2.0)
-        assert game.state.trust["forge"] == 1.0
-        game.adjust_trust(Room.FORGE, -3.0)
-        assert game.state.trust["forge"] == -1.0
-
-    def test_get_status(self):
-        game = TowerGame(seed=42)
-        game.tick()
-        status = game.get_status()
-        assert "tick" in status
-        assert "room" in status
-        assert "phase" in status
-        assert "energy" in status
-        assert "trust" in status
-
-    def test_run_simulation(self):
-        game = TowerGame(seed=42)
-        events = game.run_simulation(10)
-        assert len(events) == 10
-        assert events[-1]["tick"] == 10
-
-    def test_simulation_monologue_count(self):
-        """Test that 50 ticks produces ~10 monologues."""
-        game = TowerGame(seed=42)
-        events = game.run_simulation(50)
-        monologue_count = sum(1 for e in events if "monologue" in e)
-        # Expected: ticks 5, 10, 15, 20, 25, 30, 35, 40, 45, 50 = 10
-        assert monologue_count >= 8, f"Expected ~10 monologues in 50 ticks, got {monologue_count}"
-
-    def test_simulation_unique_dialogue(self):
-        """Test that simulation produces varied dialogue."""
-        game = TowerGame(seed=42)
-        events = game.run_simulation(50)
-        dialogues = set(e["dialogue"] for e in events)
-        assert len(dialogues) >= 10, f"Expected 10+ unique dialogues, got {len(dialogues)}"