feat: add tower world-changing items for #514

docs/LOCAL_HARDWARE_MCP.md

@@ -1,144 +0,0 @@
-# Local Hardware MCP Integration
-
-Integrate the Model Context Protocol (MCP) to allow Timmy agents to control local hardware securely: file system, smart home (Hue lights), and system information.
-
-## Components
-
-- **MCP Server**: `scripts/hardware_mcp_server.py` — stdio-based MCP server exposing 8 tools
-- **Config Template**: `timmy-local/hardware_mcp_config.yaml` — runtime tuning
-- **Smoke Tests**: `tests/test_hardware_mcp_server.py`
-
-## Prerequisites
-
-```bash
-# MCP SDK
-pip install mcp
-
-# OpenHue CLI (for smart home control)
-brew install openhue/cli/openhue   # macOS
-# or see: https://github.com/openhue/openhue-cli
-
-# Optional: psutil for detailed system_info
-pip install psutil
-```
-
-## Quick Start
-
-### 1. Start the MCP server
-
-The server runs as a subprocess launched by Hermes Agent via the native-MCP integration.
-
-Add to `~/.hermes/config.yaml`:
-
-```yaml
-mcp_servers:
-  hardware:
-    command: "python"
-    args: ["/full/path/to/timmy-home/scripts/hardware_mcp_server.py"]
-    # Optional: add env vars if needed
-    # env:
-    #   OPENHUE_BRIDGE_IP: "192.168.1.100"
-```
-
-### 2. Restart Hermes
-
-On startup, Hermes will:
-1. Launch the hardware MCP server
-2. Discover all 8 tools
-3. Register them with `hardware_*` prefixes (e.g., `hardware_file_read`, `hardware_light_control`)
-
-### 3. Use in conversation
-
-```
-User: Read my Timmy report file.
-Agent: [calls hardware_file_read with path="~/LOCAL_Timmy_REPORT.md"]
-
-User: Turn off the bedroom lights.
-Agent: [calls hardware_light_control with name="Bedroom Lamp", on=false]
-
-User: List files in my downloads folder.
-Agent: [calls hardware_file_list with directory="~/Downloads"]
-
-User: What's my system status?
-Agent: [calls hardware_system_info]
-```
-
-## Tool Reference
-
-| Tool | Purpose | Parameters |
-|------|---------|------------|
-| `hardware_file_read` | Read file (≤10 MB) from home/tmp | `path` (string) |
-| `hardware_file_write` | Write text file | `path`, `content` |
-| `hardware_file_list` | List directory contents | `directory` (default: ~) |
-| `hardware_light_list` | List all Hue lights/rooms/scenes | none |
-| `hardware_light_control` | Control individual light | `name`, `on`, `brightness`, `color`, `temperature` |
-| `hardware_room_control` | Control all lights in a room | `name`, `on`, `brightness` |
-| `hardware_scene_set` | Activate Hue scene | `scene`, `room` |
-| `hardware_system_info` | System info (OS, CPU, memory, disk) | none |
-
-## Security Model
-
-- **File path allowlist**: Only paths under `~` (home), `/tmp`, and `/private/tmp` are permitted.
-- **File size cap**: 10 MB max per read.
-- **No arbitrary commands**: Only explicit tool operations; no shell execution.
-- **Smart home requires OpenHue CLI**: Light control goes through the official Hue CLI which handles bridge authentication.
-- **Graceful degradation**: If `psutil` is missing, `system_info` returns basic platform data; if `openhue` is missing, light tools return install instructions.
-
-## Runtime Configuration
-
-Edit `~/.timmy/hardware/hardware_mcp_config.yaml` (copy from `timmy-local/hardware_mcp_config.yaml`) to adjust:
-
-```yaml
-guards:
-  max_consecutive_errors: 3
-  max_mcp_calls_per_session: 0  # 0 = unlimited
-allowed_dirs:
-  - "~"
-  - "/tmp"
-  - "/private/tmp"
-max_file_size_bytes: 10485760  # 10 MB
-```
-
-## Testing
-
-```bash
-# Validate Python syntax
-python3 -m py_compile scripts/hardware_mcp_server.py
-
-# Run smoke tests
-pytest tests/test_hardware_mcp_server.py -v
-```
-
-## Troubleshooting
-
-**MCP tools not appearing in Hermes**
-
-- Verify `mcp` Python package is installed: `pip show mcp`
-- Check `~/.hermes/config.yaml` syntax (YAML parse)
-- Restart Hermes (MCP connects at startup only)
-- Check Hermes logs: `~/.hermes/logs/` for MCP connection errors
-
-**"openhue CLI not found"**
-
-- Install OpenHue: `brew install openhue/cli/openhue`
-- First run requires pressing the Hue Bridge button to pair
-- Ensure bridge is on same local network
-
-**"Path not allowed"**
-
-- Only home (`~`), `/tmp`, and `/private/tmp` are accessible
-- Use absolute paths or `~/` expansion; relative paths are resolved from home
-
-**File too large**
-
-- Max read size is 10 MB. Split or compress large files.
-
-## Dependencies
-
-| Package | Purpose | Install |
-|---------|---------|---------|
-| `mcp` | MCP SDK (server framework) | `pip install mcp` |
-| `openhue` | Hue light control CLI | `brew install openhue/cli/openhue` |
-| `psutil` (optional) | Detailed memory/disk metrics | `pip install psutil` |
-
-## Closes #466

evennia/timmy_world/game.py

@@ -12,6 +12,29 @@ WORLD_DIR = Path('/Users/apayne/.timmy/evennia/timmy_world')
 STATE_FILE = WORLD_DIR / 'game_state.json'
 TIMMY_LOG = WORLD_DIR / 'timmy_log.md'
 
+WORLD_ITEMS = {
+    "foraged key": {"effect": "unlock_tower_cache", "quest_item": True, "consumable": False, "effect_text": "A hidden cache clicks open in the Tower wall."},
+    "seed packet": {"effect": "grow_garden", "quest_item": False, "consumable": True, "effect_text": "Fresh growth pushes through the Garden soil."},
+    "notebook": {"effect": "write_notebook_rule", "quest_item": False, "consumable": False, "effect_text": "A new rule joins the whiteboard in the Tower."},
+    "cloth": {"effect": "patch_bridge", "quest_item": False, "consumable": True, "effect_text": "The Bridge railing is wrapped tight against the weather."},
+    "oil can": {"effect": "stoke_forge", "quest_item": False, "consumable": True, "effect_text": "The Forge fire answers with a hotter glow."},
+    "lantern": {"effect": "light_bridge", "quest_item": False, "consumable": False, "effect_text": "A steady lantern glow cuts through the dark over the Bridge."},
+    "rope spool": {"effect": "secure_bridge", "quest_item": False, "consumable": True, "effect_text": "The Bridge is lashed tight and feels safer underfoot."},
+    "chalk": {"effect": "mark_threshold", "quest_item": False, "consumable": True, "effect_text": "A chalk mark at the Threshold points wanderers home."},
+    "weather vane": {"effect": "read_weather", "quest_item": False, "consumable": False, "effect_text": "The weather vane settles and the coming storm makes sense."},
+    "sunstone": {"effect": "restore_tower_power", "quest_item": False, "consumable": False, "effect_text": "Warm light races through the Tower circuits."},
+    "iron nails": {"effect": "reinforce_bridge", "quest_item": False, "consumable": True, "effect_text": "The Bridge planks are pinned down against the flood."},
+    "river stone": {"effect": "water_garden", "quest_item": False, "consumable": True, "effect_text": "Moisture returns to the Garden beds."},
+}
+
+ROOM_DISCOVERABLES = {
+    "Threshold": ["chalk", "sunstone"],
+    "Tower": ["notebook", "lantern"],
+    "Forge": ["oil can", "iron nails"],
+    "Garden": ["seed packet", "foraged key"],
+    "Bridge": ["cloth", "rope spool", "weather vane", "river stone"],
+}
+
 # ============================================================
 # NARRATIVE ARC — 4 phases that transform the world
 # ============================================================
@@ -143,6 +166,8 @@ class World:
                 "visitors": [],
             },
         }
+        for room_name, items in ROOM_DISCOVERABLES.items():
+            self.rooms[room_name]["discoverables"] = list(items)
         
         # Characters (not NPCs — they have lives)
         self.characters = {
@@ -258,6 +283,14 @@ class World:
             "items_crafted": 0,
             "conflicts_resolved": 0,
             "nights_survived": 0,
+            "bridge_patched": False,
+            "bridge_secured": False,
+            "bridge_reinforced": False,
+            "bridge_lantern_lit": False,
+            "tower_cache_unlocked": False,
+            "threshold_marked": False,
+            "weather_readable": False,
+            "sunstone_socketed": False,
         }
     
     def tick_time(self):
@@ -376,6 +409,14 @@ class World:
                 desc += " Rain mists on the dark water below."
             if len(self.rooms["Bridge"]["carvings"]) > 1:
                 desc += f" There are {len(self.rooms['Bridge']['carvings'])} carvings now."
+            if self.state.get("bridge_patched"):
+                desc += " Cloth bindings keep the railing from splintering."
+            if self.state.get("bridge_secured"):
+                desc += " Rope lines keep the span steady against the flood."
+            if self.state.get("bridge_reinforced"):
+                desc += " Fresh iron nails hold the planks tight."
+            if self.state.get("bridge_lantern_lit"):
+                desc += " A lantern glows warm over the water."
         
         elif room_name == "Tower":
             power = self.state.get("tower_power_low", False)
@@ -384,6 +425,19 @@ class World:
             
             if self.rooms["Tower"]["messages"]:
                 desc += f" The whiteboard holds {len(self.rooms['Tower']['messages'])} rules."
+            if self.state.get("tower_cache_unlocked"):
+                desc += " A hidden cache stands open beneath the whiteboard."
+
+        if room_name == "Threshold" and self.state.get("threshold_marked"):
+            desc += " A chalk arrow points late arrivals toward shelter."
+        if room_name == "Garden" and self.state.get("weather_readable"):
+            desc += " The beds are arranged to catch whatever weather comes next."
+        if room_name == "Tower" and self.state.get("sunstone_socketed"):
+            desc += " A sunstone keeps the room lit with a stubborn amber glow."
+
+        discoverables = room.get("discoverables", [])
+        if discoverables:
+            desc += f" Discoverable items: {', '.join(discoverables)}."
         
         # Who's here
         here = [n for n, c in self.characters.items() if c["room"] == room_name and n != char_name]
@@ -485,6 +539,10 @@ class ActionSystem:
             "cost": 1,
             "description": "Take an item from the room",
         },
+        "use": {
+            "cost": 1,
+            "description": "Use an item from your inventory to change the world",
+        },
         "examine": {
             "cost": 0,
             "description": "Examine something in detail",
@@ -530,6 +588,13 @@ class ActionSystem:
         available.append("rest")
         available.append("examine")
         
+        discoverables = world.rooms[room].get("discoverables", [])
+        for item in discoverables:
+            available.append(f"take:{item}")
+
+        for item in char["inventory"]:
+            available.append(f"use:{item}")
+
         if char["inventory"]:
             available.append("give:item")
         
@@ -1072,6 +1137,76 @@ class GameEngine:
                 f.write(f"\n*Began: {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n\n")
                 f.write("---\n\n")
                 f.write(message + "\n")
+
+    def _take_item(self, item_name, scene):
+        room_name = self.world.characters["Timmy"]["room"]
+        discoverables = self.world.rooms[room_name].get("discoverables", [])
+        if item_name not in discoverables:
+            scene["log"].append(f"There is no {item_name} here.")
+            return
+        discoverables.remove(item_name)
+        self.world.characters["Timmy"]["inventory"].append(item_name)
+        scene["log"].append(f"You take the {item_name}.")
+        if WORLD_ITEMS.get(item_name, {}).get("quest_item"):
+            scene["world_events"].append(f"The {item_name} feels important. It might open a quest route.")
+
+    def _use_item(self, item_name, scene):
+        inventory = self.world.characters["Timmy"]["inventory"]
+        if item_name not in inventory:
+            scene["log"].append(f"You are not carrying {item_name}.")
+            return
+        item = WORLD_ITEMS.get(item_name)
+        if not item:
+            scene["log"].append(f"The {item_name} doesn't seem to do anything.")
+            return
+
+        effect = item["effect"]
+        effect_text = item["effect_text"]
+        if effect == "grow_garden":
+            self.world.rooms["Garden"]["growth"] = min(5, self.world.rooms["Garden"]["growth"] + 2)
+            self.world.state["garden_drought"] = False
+        elif effect == "unlock_tower_cache":
+            self.world.state["tower_cache_unlocked"] = True
+            cache_rule = "Rule: Keys open more than doors when the world trusts you."
+            if cache_rule not in self.world.rooms["Tower"]["messages"]:
+                self.world.rooms["Tower"]["messages"].append(cache_rule)
+        elif effect == "write_notebook_rule":
+            note_rule = f"Rule #{self.world.tick}: A notebook can turn memory into structure."
+            self.world.rooms["Tower"]["messages"].append(note_rule)
+        elif effect == "patch_bridge":
+            self.world.state["bridge_patched"] = True
+            self.world.state["bridge_flooding"] = False
+            self.world.rooms["Bridge"]["weather"] = None
+            self.world.rooms["Bridge"]["rain_ticks"] = 0
+        elif effect == "stoke_forge":
+            self.world.rooms["Forge"]["fire"] = "glowing"
+            self.world.state["forge_fire_dying"] = False
+        elif effect == "light_bridge":
+            self.world.state["bridge_lantern_lit"] = True
+        elif effect == "secure_bridge":
+            self.world.state["bridge_secured"] = True
+            self.world.state["bridge_flooding"] = False
+            self.world.rooms["Bridge"]["weather"] = None
+            self.world.rooms["Bridge"]["rain_ticks"] = 0
+        elif effect == "mark_threshold":
+            self.world.state["threshold_marked"] = True
+        elif effect == "read_weather":
+            self.world.state["weather_readable"] = True
+            self.world.state["garden_drought"] = False
+        elif effect == "restore_tower_power":
+            self.world.state["tower_power_low"] = False
+            self.world.state["sunstone_socketed"] = True
+        elif effect == "reinforce_bridge":
+            self.world.state["bridge_reinforced"] = True
+            self.world.state["bridge_flooding"] = False
+        elif effect == "water_garden":
+            self.world.state["garden_drought"] = False
+            self.world.rooms["Garden"]["growth"] = min(5, self.world.rooms["Garden"]["growth"] + 1)
+
+        scene["log"].append(f"You use the {item_name}. {effect_text}")
+        scene["world_events"].append(effect_text)
+        if item.get("consumable"):
+            inventory.remove(item_name)
     
     def run_tick(self, timmy_action="look"):
         """Run one tick. Return the scene and available choices."""
@@ -1100,7 +1235,7 @@ class GameEngine:
         action_costs = {
             "move": 2, "tend_fire": 3, "write_rule": 2, "carve": 2,
             "plant": 2, "study": 2, "forge": 3, "help": 2, "speak": 1,
-            "listen": 0, "rest": -2, "examine": 0, "give": 0, "take": 1,
+            "listen": 0, "rest": -2, "examine": 0, "give": 0, "take": 1, "use": 1,
         }
         
         # Extract action name
@@ -1360,9 +1495,17 @@ class GameEngine:
         elif timmy_action == "examine":
             room = self.world.characters["Timmy"]["room"]
             room_data = self.world.rooms[room]
-            items = room_data.get("items", [])
+            items = room_data.get("items", []) + room_data.get("discoverables", [])
             scene["log"].append(f"You examine The {room}. You see: {', '.join(items) if items else 'nothing special'}")
         
+        elif timmy_action.startswith("take:"):
+            item_name = timmy_action.split(":", 1)[1]
+            self._take_item(item_name, scene)
+
+        elif timmy_action.startswith("use:"):
+            item_name = timmy_action.split(":", 1)[1]
+            self._use_item(item_name, scene)
+        
         elif timmy_action.startswith("help:"):
             # Help increases trust
             target_name = timmy_action.split(":")[1]

scripts/hardware_mcp_integration.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python3
-"""Local Hardware MCP operator helper — generate config snippets and verify environment."""
-
-import os
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-HERMES_CONFIG = Path.home() / ".hermes" / "config.yaml"
-HARDWARE_MCP_CONFIG = Path.home() / ".timmy" / "hardware" / "hardware_mcp_config.yaml"
-HARDWARE_SERVER = REPO_ROOT / "scripts" / "hardware_mcp_server.py"
-
-
-def build_mcp_config_snippet() -> str:
-    """Return the mcp_servers YAML snippet for ~/.hermes/config.yaml."""
-    return f"""mcp_servers:
-  hardware:
-    command: "python"
-    args: ["{HARDWARE_SERVER}"]
-"""
-
-
-def build_wakeup_hook() -> str:
-    """Return a bash snippet that can be sourced before Hermes starts (optional)."""
-    return f"""#!/usr/bin/env bash
-# Hardware MCP environment check
-if command -v openhue >/dev/null 2>&1; then
-  echo "[Hardware MCP] OpenHue found: $(openhue version)"
-else
-  echo "[Hardware MCP] Warning: openhue CLI not installed — light control disabled"
-fi
-"""
-
-
-def main():
-    import argparse
-    p = argparse.ArgumentParser(description="Hardware MCP integration helper")
-    p.add_argument("--print-config", action="store_true", help="Print mcp_servers YAML snippet")
-    p.add_argument("--print-hook", action="store_true", help="Print optional session-start hook")
-    p.add_argument("--verify", action="store_true", help="Verify server script exists and is executable")
-    args = p.parse_args()
-
-    if args.print_config:
-        print(build_mcp_config_snippet())
-    elif args.print_hook:
-        print(build_wakeup_hook())
-    elif args.verify:
-        ok = HARDWARE_SERVER.exists()
-        print(f"Server script: {'OK' if ok else 'MISSING'} at {HARDWARE_SERVER}")
-        sys.exit(0 if ok else 1)
-    else:
-        p.print_help()
-
-
-if __name__ == "__main__":
-    main()

scripts/hardware_mcp_server.py

@@ -1,206 +0,0 @@
-#!/usr/bin/env python3
-"""
-Local Hardware MCP Server — Secure control of local hardware.
-
-Exposes tools for:
-  - File system operations (read, write, list) within allowed directories
-  - Smart home control via OpenHue (Philips Hue lights)
-  - System information (safe, read-only)
-
-Security: Enforces directory allowlist for file access.
-"""
-
-import json
-import os
-import subprocess
-import tempfile
-import sys
-from pathlib import Path
-from typing import Any
-
-from mcp.server import Server
-from mcp.server.stdio import stdio_server
-from mcp.types import Tool, TextContent
-
-ALLOWED_DIRS = [
-    str(Path.home()),          # User home directory
-    "/tmp",                    # macOS symlink to /private/tmp
-    "/private/tmp",            # real tmp path
-    str(Path(tempfile.gettempdir())),  # actual system temp dir
-]
-OPENHUE_CMD = "openhue"
-MAX_FILE_SIZE = 10 * 1024 * 1024
-app = Server("hardware")
-
-
-def is_path_allowed(path: Path) -> bool:
-    try:
-        resolved = path.resolve()
-        return any(resolved.is_relative_to(Path(d).resolve()) for d in ALLOWED_DIRS)
-    except (ValueError, OSError):
-        return False
-
-
-def run_openhue(args: list[str]) -> dict[str, Any]:
-    try:
-        result = subprocess.run([OPENHUE_CMD] + args, capture_output=True, text=True, timeout=30)
-        return {
-            "success": result.returncode == 0,
-            "stdout": result.stdout.strip(),
-            "stderr": result.stderr.strip(),
-            "returncode": result.returncode,
-        }
-    except FileNotFoundError:
-        return {"success": False,
-                "error": "openhue CLI not found. Install: brew install openhue/cli/openhue"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@app.list_tools()
-async def list_tools():
-    return [
-        Tool(name="file_read",
-             description="Read a file from allowed directories (home, /tmp) up to 10 MB.",
-             inputSchema={"type": "object", "properties": {"path": {"type": "string",
-                          "description": "File path to read (e.g., ~/notes.txt)"}}, "required": ["path"]}),
-        Tool(name="file_write",
-             description="Write text content to a file within allowed directories.",
-             inputSchema={"type": "object", "properties": {"path": {"type": "string"},
-                          "content": {"type": "string"}}, "required": ["path", "content"]}),
-        Tool(name="file_list",
-             description="List files and directories in a given folder.",
-             inputSchema={"type": "object", "properties": {"directory": {"type": "string", "default": "~"}}, "required": []}),
-        Tool(name="light_list",
-             description="List all Hue lights, rooms, and scenes.",
-             inputSchema={"type": "object", "properties": {}, "required": []}),
-        Tool(name="light_control",
-             description="Control a Hue light: on/off, brightness 0-100, color name/hex, temperature 153-500 mirek.",
-             inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "on": {"type": "boolean"},
-                          "brightness": {"type": "integer", "minimum": 0, "maximum": 100},
-                          "color": {"type": "string"}, "temperature": {"type": "integer", "minimum": 153, "maximum": 500}},
-                          "required": ["name", "on"]}),
-        Tool(name="room_control",
-             description="Control all lights in a room.",
-             inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "on": {"type": "boolean"},
-                          "brightness": {"type": "integer", "minimum": 0, "maximum": 100}}, "required": ["name", "on"]}),
-        Tool(name="scene_set",
-             description="Activate a Hue scene in a room.",
-             inputSchema={"type": "object", "properties": {"scene": {"type": "string"}, "room": {"type": "string"}}, "required": ["scene", "room"]}),
-        Tool(name="system_info",
-             description="Get safe system info: OS, CPU count, memory, disk usage.",
-             inputSchema={"type": "object", "properties": {}, "required": []}),
-    ]
-
-
-@app.call_tool()
-async def call_tool(name: str, arguments: dict):
-    if name == "file_read":
-        path = Path(arguments["path"].strip()).expanduser()
-        if not is_path_allowed(path):
-            return [TextContent(type="text", text=json.dumps({"error": f"Path not allowed: {path}"}))]
-        if not path.is_file():
-            return [TextContent(type="text", text=json.dumps({"error": f"File not found: {path}"}))]
-        try:
-            size = path.stat().st_size
-            if size > MAX_FILE_SIZE:
-                return [TextContent(type="text", text=json.dumps({"error": f"File too large: {size} bytes"}))]
-            content = path.read_text()
-            return [TextContent(type="text", text=json.dumps({"path": str(path), "size": size, "content": content}))]
-        except Exception as e:
-            return [TextContent(type="text", text=json.dumps({"error": str(e)}))]
-
-    elif name == "file_write":
-        path = Path(arguments["path"].strip()).expanduser()
-        if not is_path_allowed(path):
-            return [TextContent(type="text", text=json.dumps({"error": f"Path not allowed: {path}"}))]
-        try:
-            path.parent.mkdir(parents=True, exist_ok=True)
-            path.write_text(arguments["content"])
-            return [TextContent(type="text", text=json.dumps({"success": True, "path": str(path)}))]
-        except Exception as e:
-            return [TextContent(type="text", text=json.dumps({"error": str(e)}))]
-
-    elif name == "file_list":
-        directory = Path(arguments.get("directory", "~").strip()).expanduser()
-        if not is_path_allowed(directory):
-            return [TextContent(type="text", text=json.dumps({"error": f"Directory not allowed: {directory}"}))]
-        if not directory.is_dir():
-            return [TextContent(type="text", text=json.dumps({"error": f"Not a directory: {directory}"}))]
-        try:
-            entries = []
-            for entry in sorted(directory.iterdir()):
-                try:
-                    stat = entry.stat()
-                    entries.append({"name": entry.name, "is_dir": entry.is_dir(),
-                                    "size": stat.st_size if entry.is_file() else None})
-                except (OSError, PermissionError):
-                    pass
-            return [TextContent(type="text", text=json.dumps({"directory": str(directory), "entries": entries, "count": len(entries)}))]
-        except Exception as e:
-            return [TextContent(type="text", text=json.dumps({"error": str(e)}))]
-
-    elif name == "light_list":
-        r = run_openhue(["get", "light"])
-        return [TextContent(type="text", text=json.dumps(r))]
-
-    elif name == "light_control":
-        args = ["set", "light", f'"{arguments["name"]}"']
-        if arguments.get("on") is not None:
-            args.append("--on" if arguments["on"] else "--off")
-        if brightness := arguments.get("brightness"):
-            args.append(f"--brightness {brightness}")
-        if color := arguments.get("color"):
-            args.append(f"--color {color}")
-        if temperature := arguments.get("temperature"):
-            args.append(f"--temperature {temperature}")
-        return [TextContent(type="text", text=json.dumps(run_openhue(args)))]
-
-    elif name == "room_control":
-        args = ["set", "room", f'"{arguments["name"]}"']
-        if arguments.get("on") is not None:
-            args.append("--on" if arguments["on"] else "--off")
-        if brightness := arguments.get("brightness"):
-            args.append(f"--brightness {brightness}")
-        return [TextContent(type="text", text=json.dumps(run_openhue(args)))]
-
-    elif name == "scene_set":
-        args = ["set", "scene", arguments["scene"], "--room", arguments["room"]]
-        return [TextContent(type="text", text=json.dumps(run_openhue(args)))]
-
-    elif name == "system_info":
-        try:
-            import platform
-            info = {"platform": platform.system(), "release": platform.release(),
-                    "arch": platform.machine(), "hostname": platform.node(),
-                    "cpu_count": os.cpu_count()}
-            try:
-                import psutil
-                mem = psutil.virtual_memory()
-                info["memory_gb"] = round(mem.total / (1024**3), 2)
-                disk = psutil.disk_usage(str(Path.home()))
-                info["disk_home_gb"] = round(disk.total / (1024**3), 2)
-            except ImportError:
-                info["memory_gb"] = "psutil not installed"
-                info["disk_home_gb"] = "psutil not installed"
-            return [TextContent(type="text", text=json.dumps(info, indent=2))]
-        except Exception as e:
-            return [TextContent(type="text", text=json.dumps({"error": str(e)}))]
-
-    else:
-        return [TextContent(type="text", text=json.dumps({
-            "error": f"Unknown tool: {name}",
-            "available": ["file_read", "file_write", "file_list", "light_list",
-                         "light_control", "room_control", "scene_set", "system_info"],
-        }))]
-
-
-async def main():
-    async with stdio_server() as (rs, ws):
-        await app.run(rs, ws, app.create_initialization_options())
-
-
-if __name__ == "__main__":
-    import asyncio
-    asyncio.run(main())
-

tests/test_hardware_mcp_functional.py

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-"""Functional test for hardware_mcp_server — uses asyncio.get_event_loop for restricted envs."""
-
-import asyncio, json, tempfile, sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-from scripts.hardware_mcp_server import call_tool, is_path_allowed
-
-async def run_tests():
-    # Path allowlist
-    assert is_path_allowed(Path.home() / "any.txt")
-    assert is_path_allowed(Path("/tmp/foo"))
-    assert not is_path_allowed(Path("/etc/passwd"))
-    print("✓ Path allowlist")
-
-    # file_list on home
-    res = await call_tool("file_list", {"directory": "~"})
-    data = json.loads(res[0].text)
-    assert "entries" in data and data["count"] >= 0
-    print(f"✓ file_list works, entries: {data['count']}")
-
-    # file_write + file_read round-trip in temp dir
-    with tempfile.TemporaryDirectory() as td:
-        fp = Path(td) / "hmcp_test.txt"
-        content = "Hardware MCP round-trip OK"
-        w = await call_tool("file_write", {"path": str(fp), "content": content})
-        assert json.loads(w[0].text).get("success")
-        r = await call_tool("file_read", {"path": str(fp)})
-        assert json.loads(r[0].text)["content"] == content
-    print("✓ file write/read round-trip")
-
-    # file_read error: missing file
-    err = await call_tool("file_read", {"path": str(Path.home() / "no_such_file_xyz")})
-    assert "error" in json.loads(err[0].text)
-    print("✓ file_read reports missing file")
-
-    # Security: path traversal blocked
-    block = await call_tool("file_read", {"path": "/etc/passwd"})
-    bd = json.loads(block[0].text)
-    assert "not allowed" in bd.get("error", "").lower()
-    print("✓ Path traversal blocked")
-
-    print("\nAll functional checks passed!")
-
-if __name__ == "__main__":
-    # Use get_event_loop for environments where asyncio.run is disabled
-    try:
-        asyncio.run(run_tests())
-    except RuntimeError:
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(run_tests())

tests/test_hardware_mcp_server.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-"""Smoke tests for hardware_mcp_server."""
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-from unittest import TestCase
-
-# Add repo root to path
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT))
-
-
-class TestHardwareMCPToolDefinitions(TestCase):
-    """Verify the MCP server is well-formed and tools have required schemas."""
-
-    def test_server_imports(self):
-        """Server module must import cleanly."""
-        import importlib.util
-        spec = importlib.util.spec_from_file_location(
-            "hardware_mcp_server",
-            ROOT / "scripts" / "hardware_mcp_server.py"
-        )
-        self.assertIsNotNone(spec)
-        mod = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-        self.assertTrue(hasattr(mod, "app"))
-        self.assertTrue(hasattr(mod, "list_tools"))
-        self.assertTrue(hasattr(mod, "call_tool"))
-
-    def test_list_tools_returns_at_least_five_tools(self):
-        """list_tools() must return multiple tools covering file ops, lights, and system info."""
-        import asyncio
-        from scripts.hardware_mcp_server import list_tools
-        tools = asyncio.run(list_tools())
-        tool_names = [t.name for t in tools]
-        # Core capabilities
-        self.assertIn("file_read", tool_names)
-        self.assertIn("file_write", tool_names)
-        self.assertIn("file_list", tool_names)
-        self.assertIn("light_list", tool_names)
-        self.assertIn("light_control", tool_names)
-        self.assertIn("room_control", tool_names)
-        self.assertIn("scene_set", tool_names)
-        self.assertIn("system_info", tool_names)
-        self.assertGreaterEqual(len(tools), 8)
-
-    def test_file_read_schema_requires_path(self):
-        """file_read tool must require 'path' parameter."""
-        import asyncio
-        from scripts.hardware_mcp_server import list_tools
-        tools = asyncio.run(list_tools())
-        ft = next(t for t in tools if t.name == "file_read")
-        self.assertIn("path", ft.inputSchema["properties"])
-        self.assertIn("path", ft.inputSchema["required"])
-
-    def test_light_control_schema_requires_name_and_on(self):
-        """light_control requires name and on."""
-        import asyncio
-        from scripts.hardware_mcp_server import list_tools
-        tools = asyncio.run(list_tools())
-        ft = next(t for t in tools if t.name == "light_control")
-        self.assertIn("name", ft.inputSchema["required"])
-        self.assertIn("on", ft.inputSchema["required"])
-
-    def test_system_info_is_readonly(self):
-        """system_info tool takes no arguments."""
-        import asyncio
-        from scripts.hardware_mcp_server import list_tools
-        tools = asyncio.run(list_tools())
-        ft = next(t for t in tools if t.name == "system_info")
-        self.assertEqual(ft.inputSchema.get("required", []), [])
-        self.assertEqual(len(ft.inputSchema.get("properties", {})), 0)
-
-    def test_file_write_path_allowed_check(self):
-        """File write must enforce path allowlist (regression guard)."""
-        from scripts.hardware_mcp_server import is_path_allowed, Path
-        self.assertTrue(is_path_allowed(Path.home() / "test.txt"))
-        self.assertTrue(is_path_allowed(Path("/tmp/test.txt")))
-        # Outside allowed dirs should be rejected
-        self.assertFalse(is_path_allowed(Path("/etc/passwd")))
-
-    def test_run_openhue_error_handling(self):
-        """openhue runner returns structured error when CLI missing."""
-        from scripts.hardware_mcp_server import run_openhue
-        result = run_openhue(["get", "light"])
-        # On a system without openhue, must return success=False with helpful error
-        self.assertIn("success", result)
-        if not result.get("success"):
-            self.assertIn("error", result)
-            self.assertIn("openhue", result.get("error", "").lower())
-
-
-class TestHardwareMCPConfigCompleteness(TestCase):
-    """Validate config template matches tool set."""
-
-    def test_config_template_exists(self):
-        self.assertTrue((ROOT / "timmy-local" / "hardware_mcp_config.yaml").exists())
-
-    def test_config_lists_all_tools(self):
-        with open(ROOT / "timmy-local" / "hardware_mcp_config.yaml") as f:
-            content = f.read()
-        # All tool names should appear in the tools: section
-        for tool in ["file_read", "file_write", "file_list", "light_list",
-                     "light_control", "room_control", "scene_set", "system_info"]:
-            self.assertIn(tool, content, f"Tool {tool} missing from config tools list")
-
-    def test_config_has_security_guards(self):
-        with open(ROOT / "timmy-local" / "hardware_mcp_config.yaml") as f:
-            content = f.read()
-        self.assertIn("max_consecutive_errors", content)
-        self.assertIn("allowed_dirs", content)
-        self.assertIn("max_file_size_bytes", content)
-
-    def test_config_has_server_key(self):
-        with open(ROOT / "timmy-local" / "hardware_mcp_config.yaml") as f:
-            content = f.read()
-        self.assertIn("server_key: hardware", content)
-
-
-if __name__ == "__main__":
-    import unittest
-    unittest.main()

tests/test_tower_game_items.py

@@ -0,0 +1,58 @@
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+import unittest
+
+
+ROOT = Path(__file__).resolve().parent.parent
+GAME_PATH = ROOT / "evennia" / "timmy_world" / "game.py"
+
+
+def load_game_module():
+    spec = spec_from_file_location("tower_game_items", GAME_PATH)
+    module = module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+    module.random.seed(0)
+    return module
+
+
+class TestTowerGameWorldItems(unittest.TestCase):
+    def test_world_has_ten_unique_items_and_a_quest_item(self):
+        module = load_game_module()
+        world = module.World()
+
+        room_items = {
+            item
+            for room in world.rooms.values()
+            for item in room.get("discoverables", [])
+        }
+
+        self.assertGreaterEqual(len(room_items), 10)
+        self.assertIn("foraged key", room_items)
+        self.assertTrue(module.WORLD_ITEMS["foraged key"]["quest_item"])
+
+    def test_items_change_world_state_when_used(self):
+        module = load_game_module()
+        engine = module.GameEngine()
+        engine.start_new_game()
+        engine.world.characters["Timmy"]["energy"] = 10
+        engine.world.characters["Timmy"]["room"] = "Garden"
+
+        initial_growth = engine.world.rooms["Garden"]["growth"]
+        engine.run_tick("take:seed packet")
+        use_seed = engine.run_tick("use:seed packet")
+
+        self.assertGreater(engine.world.rooms["Garden"]["growth"], initial_growth)
+        self.assertNotIn("seed packet", engine.world.characters["Timmy"]["inventory"])
+        self.assertTrue(any("garden" in line.lower() for line in use_seed["world_events"] + use_seed["log"]))
+
+        engine.world.characters["Timmy"]["energy"] = 10
+        engine.run_tick("take:foraged key")
+        use_key = engine.run_tick("use:foraged key")
+
+        self.assertTrue(engine.world.state["tower_cache_unlocked"])
+        self.assertTrue(any("cache" in line.lower() or "quest" in line.lower() for line in use_key["world_events"] + use_key["log"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

timmy-local/hardware/README.md

@@ -1,3 +0,0 @@
-# hardware MCP config
-
-Copy `hardware_mcp_config.yaml` to `~/.timmy/hardware/hardware_mcp_config.yaml` to enable runtime tuning.

timmy-local/hardware_mcp_config.yaml

@@ -1,67 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════
-# Local Hardware MCP — Runtime Configuration
-# ═══════════════════════════════════════════════════════════════════════
-# Edit this file to tune hardware control settings.
-# Hermes loads this at session start when the hardware MCP server is enabled.
-#
-# Location: ~/.timmy/hardware/hardware_mcp_config.yaml
-# ═══════════════════════════════════════════════════════════════════════
-
-# ── Server Identity ───────────────────────────────────────────────────
-server_key: hardware
-
-# ── Tool Names ────────────────────────────────────────────────────────
-# Exact tool names Hermes registers.  Update if you rename tools in
-# hardware_mcp_server.py.
-tools:
-  - name: file_read
-    hint: "Read a file from an allowed directory (home, /tmp). Max 10 MB."
-  - name: file_write
-    hint: "Write text content to a file within allowed directories."
-  - name: file_list
-    hint: "List files and directories in a given folder."
-  - name: light_list
-    hint: "List all Hue lights, rooms, and scenes from OpenHue."
-  - name: light_control
-    hint: "Control a specific Hue light: on/off, brightness, color, temperature."
-  - name: room_control
-    hint: "Control all lights in a room: on/off, brightness."
-  - name: scene_set
-    hint: "Activate a Hue scene in a room."
-  - name: system_info
-    hint: "Get safe system information: OS, CPU count, memory usage, disk space."
-
-# ── Security Guards ───────────────────────────────────────────────────
-guards:
-  # Maximum consecutive tool errors before stopping.
-  max_consecutive_errors: 3
-
-  # Max total hardware MCP calls per session (0 = unlimited).
-  max_mcp_calls_per_session: 0
-
-  # Allowed directories for file operations (expanded paths).
-  allowed_dirs:
-    - "~"
-    - "/tmp"
-    - "/private/tmp"
-
-  # Maximum file size for reads (bytes).
-  max_file_size_bytes: 10485760  # 10 MB
-
-# ── OpenHue ───────────────────────────────────────────────────────────
-# Path to openhue CLI (auto-detected if in PATH).
-openhue_command: "openhue"
-
-# ── Dependencies ───────────────────────────────────────────────────────
-# Prerequisites:
-#   - OpenHue CLI: brew install openhue/cli/openhue (macOS) or see https://github.com/openhue/openhue-cli
-#   - MCP SDK: pip install mcp
-#   - For system_info: pip install psutil (optional, for detailed memory/disk metrics)
-#
-# Config in ~/.hermes/config.yaml:
-#   mcp_servers:
-#     hardware:
-#       command: "python"
-#       args: ["/Users/you/path/to/timmy-home/scripts/hardware_mcp_server.py"]
-#       env:
-#         OPENHUE_BRIDGE_IP: "192.168.1.xx"  # optional, if openhue needs it