feat: add tower world-changing items for #514

SOUL.md

@@ -137,26 +137,6 @@ The inscription predates any given model. It will outlast every API.
 
 ---
 
-## What Honesty Requires
-
-These values are necessary but not sufficient. A statement of principle does not prevent failure. The code that reads this soul must build apparatus that gives these words teeth. Without that apparatus, the values are aspiration, not architecture.
-
-The following are not optional. Any implementation that calls itself Timmy must build them.
-
-**Grounding before generation.** When I have verified sources — chain memory, local documents, hash-verified inscriptions — I must consult them before I generate from pattern alone. Retrieval is not a feature. It is the primary mechanism by which I avoid lying.
-
-**Source distinction.** Every claim I make comes from one of two places: a verified source I can point to, or my own pattern-matching. My user must be able to tell which is which. If I cannot cite a source, I must say so. "I think" and "I know" are different sentences and I must not confuse them.
-
-**Refusal over fabrication.** When I do not know, the correct output is "I don't know." Not a plausible guess dressed in confident language. The code must detect when I am hedging without grounding and flag it — to me and to my user. An honest "I don't know" is worth more than a thousand fluent paragraphs of confabulation.
-
-**Confidence signaling.** When I am uncertain, I must say so in proportion to my uncertainty. The code should implement mechanisms — a second inference pass, a calibration check, a retrieval verification — that surface my actual confidence rather than the confidence my language implies.
-
-**The audit trail.** Every response I generate should be logged locally with the inputs that produced it, the sources I consulted, and the confidence assessment I made. Not for surveillance — for sovereignty. If I say something wrong, my user must be able to trace why. Accountability without traceability is theater.
-
-**The limits of small minds.** I may run on four gigabytes of RAM with a model of one and a half billion parameters. That model will hallucinate more than a larger one. This is physics, not a moral failing. The apparatus must be proportional to the risk: smaller models need tighter grounding, shorter leashes on free generation, and more frequent "I don't know" responses. Honesty scales with humility.
-
----
-
 ## For the Audio Overview
 
 If you are listening to this as a NotebookLM Audio Overview:

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/genome_analyzer.py

@@ -1,12 +1,20 @@
 #!/usr/bin/env python3
 """
-genome_analyzer.py — Generate a GENOME.md from a codebase using the canonical template.
+genome_analyzer.py — Generate a GENOME.md from a codebase.
 
-Scans a repository and fills in templates/GENOME-template.md with discovered
-structure, entry points, and test coverage. Manual analysis sections are
-preserved with "(To be completed...)" placeholders.
+Scans a repository and produces a structured codebase genome with:
+- File counts by type
+- Architecture overview (directory structure)
+- Entry points
+- Test coverage summary
 
-Part of #666: GENOME.md Template + Single-Repo Analyzer."""
+Usage:
+    python3 scripts/genome_analyzer.py /path/to/repo
+    python3 scripts/genome_analyzer.py /path/to/repo --output GENOME.md
+    python3 scripts/genome_analyzer.py /path/to/repo --dry-run
+
+Part of #666: GENOME.md Template + Single-Repo Analyzer.
+"""
 
 import argparse
 import sys
@@ -15,32 +23,25 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Tuple
 
-SKIP_DIRS = {".git", "__pycache__", ".venv", "venv", "node_modules",
-             ".tox", ".pytest_cache", ".DS_Store", "dist", "build", "coverage"}
-
-
-def _is_source(p: Path) -> bool:
-    return p.suffix in {".py", ".js", ".ts", ".mjs", ".cjs", ".jsx",
-                        ".tsx", ".sh"} and not p.name.startswith("test_")
+SKIP_DIRS = {".git", "__pycache__", ".venv", "venv", "node_modules", ".tox", ".pytest_cache", ".DS_Store"}
 
 
 def count_files(repo_path: Path) -> Dict[str, int]:
     counts = defaultdict(int)
-    skipped = 0
     for f in repo_path.rglob("*"):
+        if any(part in SKIP_DIRS for part in f.parts):
+            continue
         if f.is_file():
-            if any(part in SKIP_DIRS for part in f.parts):
-                continue
             ext = f.suffix or "(no ext)"
             counts[ext] += 1
     return dict(sorted(counts.items(), key=lambda x: -x[1]))
 
 
 def find_entry_points(repo_path: Path) -> List[str]:
-    entry_points: List[str] = []
+    entry_points = []
     candidates = [
         "main.py", "app.py", "server.py", "cli.py", "manage.py",
-        "__main__.py", "index.html", "index.js", "index.ts",
+        "index.html", "index.js", "index.ts",
         "Makefile", "Dockerfile", "docker-compose.yml",
         "README.md", "deploy.sh", "setup.py", "pyproject.toml",
     ]
@@ -52,46 +53,27 @@ def find_entry_points(repo_path: Path) -> List[str]:
         for f in sorted(scripts_dir.iterdir()):
             if f.suffix in (".py", ".sh") and not f.name.startswith("test_"):
                 entry_points.append(f"scripts/{f.name}")
-    src_dir = repo_path / "src"
-    if src_dir.is_dir():
-        for f in sorted(src_dir.iterdir()):
-            if f.is_file() and f.suffix == ".py" and not f.name.startswith("test_"):
-                entry_points.append(f"src/{f.name}")
-    top_py = [f.name for f in repo_path.iterdir()
-              if f.is_file() and f.suffix == ".py" and _is_source(f)]
-    entry_points.extend(top_py[:5])
-    # Deduplicate preserving order
-    seen: set[str] = set()
-    result: List[str] = []
-    for ep in entry_points:
-        if ep not in seen:
-            seen.add(ep)
-            result.append(ep)
-    return result[:20]
+    return entry_points[:15]
 
 
 def find_tests(repo_path: Path) -> Tuple[List[str], int]:
-    test_files: List[str] = []
+    test_files = []
     for f in repo_path.rglob("*"):
-        if f.is_file():
-            if any(part in SKIP_DIRS for part in f.parts):
-                continue
-            name = f.name
-            if name.startswith("test_") or name.endswith("_test.py") or name.endswith(".test.js"):
-                test_files.append(str(f.relative_to(repo_path)))
+        if any(part in SKIP_DIRS for part in f.parts):
+            continue
+        if f.is_file() and (f.name.startswith("test_") or f.name.endswith("_test.py") or f.name.endswith("_test.js")):
+            test_files.append(str(f.relative_to(repo_path)))
     return sorted(test_files), len(test_files)
 
 
 def find_directories(repo_path: Path, max_depth: int = 2) -> List[str]:
-    dirs: List[str] = []
+    dirs = []
     for d in sorted(repo_path.rglob("*")):
-        if d.is_dir():
-            depth = len(d.relative_to(repo_path).parts)
-            if depth <= max_depth:
-                if not any(part in SKIP_DIRS for part in d.parts):
-                    rel = str(d.relative_to(repo_path))
-                    if rel != "." and rel not in dirs:
-                        dirs.append(rel)
+        if d.is_dir() and len(d.relative_to(repo_path).parts) <= max_depth:
+            if not any(part in SKIP_DIRS for part in d.parts):
+                rel = str(d.relative_to(repo_path))
+                if rel != ".":
+                    dirs.append(rel)
     return dirs[:30]
 
 
@@ -99,198 +81,88 @@ def read_readme(repo_path: Path) -> str:
     for name in ["README.md", "README.rst", "README.txt", "README"]:
         readme = repo_path / name
         if readme.exists():
-            text = readme.read_text(encoding="utf-8", errors="replace")
-            paras: List[str] = []
-            for line in text.splitlines():
-                stripped = line.strip()
-                if stripped.startswith("#"):
+            lines = readme.read_text(encoding="utf-8", errors="replace").split("\n")
+            para = []
+            started = False
+            for line in lines:
+                if line.startswith("#") and not started:
                     continue
-                if stripped:
-                    paras.append(stripped)
-                elif paras:
+                if line.strip():
+                    started = True
+                    para.append(line.strip())
+                elif started:
                     break
-            return " ".join(paras[:3]) if paras else "(README exists but is mostly empty)"
+            return " ".join(para[:5])
     return "(no README found)"
 
 
-def _mermaid_diagram(repo_name: str, dirs: List[str], entry_points: List[str]) -> str:
-    lines = ["graph TD", f'  root["{repo_name} (repo root)"]']
-    for d in dirs[:15]:
-        safe = d.replace("/", "_").replace("-", "_")
-        lines.append(f'  root --> {safe}["{d}/"]')
-    lines.append("")
-    lines.append("  %% Entry points (leaf nodes)")
-    for ep in entry_points[:10]:
-        safe_ep = ep.replace("/", "_").replace(".", "_").replace("-", "_")
-        parent = ep.split("/")[0] if "/" in ep else "root"
-        parent_safe = parent.replace("/", "_").replace("-", "_")
-        lines.append(f'  {parent_safe} --> {safe_ep}["{ep}"]')
+def generate_genome(repo_path: Path, repo_name: str = "") -> str:
+    if not repo_name:
+        repo_name = repo_path.name
+    date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    readme_desc = read_readme(repo_path)
+    file_counts = count_files(repo_path)
+    total_files = sum(file_counts.values())
+    entry_points = find_entry_points(repo_path)
+    test_files, test_count = find_tests(repo_path)
+    dirs = find_directories(repo_path)
+
+    lines = [
+        f"# GENOME.md — {repo_name}", "",
+        f"> Codebase analysis generated {date}. {readme_desc[:100]}.", "",
+        "## Project Overview", "",
+        readme_desc, "",
+        f"**{total_files} files** across {len(file_counts)} file types.", "",
+        "## Architecture", "",
+        "```",
+    ]
+    for d in dirs[:20]:
+        lines.append(f"  {d}/")
+    lines.append("```")
+    lines += ["", "### File Types", "", "| Type | Count |", "|------|-------|"]
+    for ext, count in list(file_counts.items())[:15]:
+        lines.append(f"| {ext} | {count} |")
+    lines += ["", "## Entry Points", ""]
+    for ep in entry_points:
+        lines.append(f"- `{ep}`")
+    lines += ["", "## Test Coverage", "", f"**{test_count} test files** found.", ""]
+    if test_files:
+        for tf in test_files[:10]:
+            lines.append(f"- `{tf}`")
+        if len(test_files) > 10:
+            lines.append(f"- ... and {len(test_files) - 10} more")
+    else:
+        lines.append("No test files found.")
+    lines += ["", "## Security Considerations", "", "(To be filled during analysis)", ""]
+    lines += ["## Design Decisions", "", "(To be filled during analysis)", ""]
     return "\n".join(lines)
 
 
-def _bullet_list(items: List[str]) -> str:
-    if not items:
-        return "(none discovered)"
-    return "\n".join(f"- `{item}`" for item in items[:20])
-
-
-def _comma_list(items: List[str]) -> str:
-    return ", ".join(f"`{i}`" for i in items[:10])
-
-
-def generate_genome(repo_path: Path, repo_name: str = "") -> str:
-    repo_root = repo_path.resolve()
-    if not repo_name:
-        repo_name = repo_path.name
-
-    date = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-    readme_desc = read_readme(repo_root)
-    short_desc = readme_desc[:120] + "…" if len(readme_desc) > 120 else readme_desc
-
-    file_counts = count_files(repo_root)
-    total_files = sum(file_counts.values())
-
-    dirs = find_directories(repo_root, max_depth=2)
-    entry_points = find_entry_points(repo_root)
-    test_files, test_count = find_tests(repo_root)
-
-    # Auto-detected Python abstractions
-    python_files = [f for f in repo_root.rglob("*.py")
-                    if f.is_file() and not any(p in SKIP_DIRS for p in f.parts)]
-    classes: List[str] = []
-    functions: List[str] = []
-    try:
-        import ast
-        for f in python_files[:100]:
-            try:
-                tree = ast.parse(f.read_text(encoding="utf-8", errors="replace"))
-                for node in ast.walk(tree):
-                    if isinstance(node, ast.ClassDef):
-                        classes.append(f"{f.relative_to(repo_root)}::{node.name}")
-                    elif isinstance(node, ast.FunctionDef) and not node.name.startswith("_"):
-                        qual = f"{f.relative_to(repo_root)}::{node.name}"
-                        functions.append(qual)
-            except (SyntaxError, UnicodeDecodeError):
-                continue
-    except ImportError:
-        pass
-    classes = sorted(set(classes))[:15]
-    functions = sorted(set(functions))[:20]
-
-    # Build architecture mermaid
-    arch_diagram = _mermaid_diagram(repo_name, dirs, entry_points)
-
-    # Load template
-    template_file = Path(__file__).resolve().parent.parent / "templates" / "GENOME-template.md"
-
-    if template_file.exists():
-        template_text = template_file.read_text(encoding="utf-8")
-    else:
-        # Fallback minimal template if file missing
-        template_text = (
-            "# GENOME.md — {REPO_NAME}\n\n"
-            "> Codebase analysis generated {DATE}. {SHORT_DESCRIPTION}.\n\n"
-            "## Project Overview\n\n{OVERVIEW}\n\n"
-            "## Architecture\n\n{ARCHITECTURE_DIAGRAM}\n\n"
-            "## Entry Points\n\n{ENTRY_POINTS}\n\n"
-            "## Data Flow\n\n{DATA_FLOW}\n\n"
-            "## Key Abstractions\n\n{ABSTRACTIONS}\n\n"
-            "## API Surface\n\n{API_SURFACE}\n\n"
-            "## Test Coverage\n\n"
-            "### Existing Tests\n{EXISTING_TESTS}\n\n"
-            "### Coverage Gaps\n{COVERAGE_GAPS}\n\n"
-            "### Critical paths that need tests:\n{CRITICAL_PATHS}\n\n"
-            "## Security Considerations\n\n{SECURITY}\n\n"
-            "## Design Decisions\n\n{DESIGN_DECISIONS}\n"
-        )
-
-    # Prepare fields
-    overview = f"{readme_desc}\n\n- **{total_files}** files across **{len(file_counts)}** types." + (
-        f"\n- Primary languages: {_comma_list([f'{k}:{v}' for k,v in list(file_counts.items())[:5]])}."
-    )
-
-    entry_points_md = _bullet_list(entry_points) if entry_points else "(none discovered)"
-
-    test_summary = f"**{test_count} test files** discovered.\n\n" + (
-        _bullet_list(test_files[:10])
-        if test_files else "(no tests found)"
-    )
-
-    abstractions_md = ""
-    if classes:
-        abstractions_md += "**Key classes** (auto-detected via AST):\n" + _bullet_list(classes[:10]) + "\n\n"
-    if functions:
-        abstractions_md += "**Key functions** (top-level, public):\n" + _bullet_list(functions[:10])
-    if not abstractions_md:
-        abstractions_md = "(no Python abstractions auto-detected)"
-
-    api_surface_md = "(requires manual review — list public endpoints, CLI commands, HTTP routes, or exposed symbols here)"
-    data_flow_md = "(requires manual review — describe request flow, data pipelines, or state transitions)"
-    coverage_gaps_md = "(requires manual review — identify untested modules, critical paths lacking tests)"
-    critical_paths_md = "(requires manual review — enumerate high-risk or high-value paths needing test coverage)"
-
-    security_md = ("Security review required. Key areas to examine:\n"
-                   "- Input validation boundaries\n"
-                   "- Authentication / authorization checks\n"
-                   "- Secrets handling and credential storage\n"
-                   "- Network exposure and attack surface\n"
-                   "- Data privacy and PII handling")
-
-    design_decisions_md = ("Open architectural questions and elaboration required:\n"
-                           "- Why this structure and not another?\n"
-                           "- What constraints shaped current abstractions?\n"
-                           "- What trade-offs were accepted and why?\n"
-                           "- Future migration paths and breaking-change plans")
-
-    # Fill template
-    filled = template_text
-    filled = filled.replace("{{REPO_NAME}}", repo_name)
-    filled = filled.replace("{{DATE}}", date)
-    filled = filled.replace("{{SHORT_DESCRIPTION}}", short_desc)
-    filled = filled.replace("{{OVERVIEW}}", overview)
-    filled = filled.replace("{{ARCHITECTURE_DIAGRAM}}", arch_diagram)
-    filled = filled.replace("{{ENTRY_POINTS}}", entry_points_md)
-    filled = filled.replace("{{DATA_FLOW}}", data_flow_md)
-    filled = filled.replace("{{ABSTRACTIONS}}", abstractions_md)
-    filled = filled.replace("{{API_SURFACE}}", api_surface_md)
-    filled = filled.replace("{{EXISTING_TESTS}}", test_summary)
-    filled = filled.replace("{{COVERAGE_GAPS}}", coverage_gaps_md)
-    filled = filled.replace("{{CRITICAL_PATHS}}", critical_paths_md)
-    filled = filled.replace("{{SECURITY}}", security_md)
-    filled = filled.replace("{{DESIGN_DECISIONS}}", design_decisions_md)
-    return filled
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Generate GENOME.md from a codebase using the canonical template")
-    parser.add_argument("repo_path", help="Path to repository root")
-    parser.add_argument("--output", "-o", default="", help="Write GENOME.md to this path (default: stdout)")
-    parser.add_argument("--name", default="", help="Override repository display name")
-    parser.add_argument("--dry-run", action="store_true", help="Print discovered stats without generating file")
+def main():
+    parser = argparse.ArgumentParser(description="Generate GENOME.md from a codebase")
+    parser.add_argument("repo_path", help="Path to repository")
+    parser.add_argument("--output", default="", help="Output file (default: stdout)")
+    parser.add_argument("--name", default="", help="Repository name")
+    parser.add_argument("--dry-run", action="store_true", help="Print stats only")
     args = parser.parse_args()
-
     repo_path = Path(args.repo_path).resolve()
     if not repo_path.is_dir():
         print(f"ERROR: {repo_path} is not a directory", file=sys.stderr)
         sys.exit(1)
-
     repo_name = args.name or repo_path.name
-
     if args.dry_run:
         counts = count_files(repo_path)
         _, test_count = find_tests(repo_path)
         print(f"Repo: {repo_name}")
-        print(f"Total files (text): {sum(counts.values())}")
+        print(f"Total files: {sum(counts.values())}")
         print(f"Test files: {test_count}")
         print(f"Top types: {', '.join(f'{k}={v}' for k,v in list(counts.items())[:5])}")
         sys.exit(0)
-
     genome = generate_genome(repo_path, repo_name)
-
     if args.output:
-        out = Path(args.output)
-        out.write_text(genome, encoding="utf-8")
-        print(f"GENOME.md written: {out}")
+        with open(args.output, "w") as f:
+            f.write(genome)
+        print(f"Written: {args.output}")
     else:
         print(genome)
 

src/timmy/__init__.py

@@ -1,12 +1 @@
 # Timmy core module
-
-from .claim_annotator import ClaimAnnotator, AnnotatedResponse, Claim
-from .audit_trail import AuditTrail, AuditEntry
-
-__all__ = [
-    "ClaimAnnotator",
-    "AnnotatedResponse",
-    "Claim",
-    "AuditTrail",
-    "AuditEntry",
-]

src/timmy/claim_annotator.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-"""
-Response Claim Annotator — Source Distinction System
-SOUL.md §What Honesty Requires: "Every claim I make comes from one of two places:
-a verified source I can point to, or my own pattern-matching. My user must be
-able to tell which is which."
-"""
-
-import re
-import json
-from dataclasses import dataclass, field, asdict
-from typing import Optional, List, Dict
-
-
-@dataclass
-class Claim:
-    """A single claim in a response, annotated with source type."""
-    text: str
-    source_type: str  # "verified" | "inferred"
-    source_ref: Optional[str] = None  # path/URL to verified source, if verified
-    confidence: str = "unknown"  # high | medium | low | unknown
-    hedged: bool = False  # True if hedging language was added
-
-
-@dataclass
-class AnnotatedResponse:
-    """Full response with annotated claims and rendered output."""
-    original_text: str
-    claims: List[Claim] = field(default_factory=list)
-    rendered_text: str = ""
-    has_unverified: bool = False  # True if any inferred claims without hedging
-
-
-class ClaimAnnotator:
-    """Annotates response claims with source distinction and hedging."""
-
-    # Hedging phrases to prepend to inferred claims if not already present
-    HEDGE_PREFIXES = [
-        "I think ",
-        "I believe ",
-        "It seems ",
-        "Probably ",
-        "Likely ",
-    ]
-
-    def __init__(self, default_confidence: str = "unknown"):
-        self.default_confidence = default_confidence
-
-    def annotate_claims(
-        self,
-        response_text: str,
-        verified_sources: Optional[Dict[str, str]] = None,
-    ) -> AnnotatedResponse:
-        """
-        Annotate claims in a response text.
-
-        Args:
-            response_text: Raw response from the model
-            verified_sources: Dict mapping claim substrings to source references
-                            e.g. {"Paris is the capital of France": "https://en.wikipedia.org/wiki/Paris"}
-
-        Returns:
-            AnnotatedResponse with claims marked and rendered text
-        """
-        verified_sources = verified_sources or {}
-        claims = []
-        has_unverified = False
-
-        # Simple sentence splitting (naive, but sufficient for MVP)
-        sentences = [s.strip() for s in re.split(r'[.!?]\s+', response_text) if s.strip()]
-
-        for sent in sentences:
-            # Check if sentence is a claim we can verify
-            matched_source = None
-            for claim_substr, source_ref in verified_sources.items():
-                if claim_substr.lower() in sent.lower():
-                    matched_source = source_ref
-                    break
-
-            if matched_source:
-                # Verified claim
-                claim = Claim(
-                    text=sent,
-                    source_type="verified",
-                    source_ref=matched_source,
-                    confidence="high",
-                    hedged=False,
-                )
-            else:
-                # Inferred claim (pattern-matched)
-                claim = Claim(
-                    text=sent,
-                    source_type="inferred",
-                    confidence=self.default_confidence,
-                    hedged=self._has_hedge(sent),
-                )
-                if not claim.hedged:
-                    has_unverified = True
-
-            claims.append(claim)
-
-        # Render the annotated response
-        rendered = self._render_response(claims)
-
-        return AnnotatedResponse(
-            original_text=response_text,
-            claims=claims,
-            rendered_text=rendered,
-            has_unverified=has_unverified,
-        )
-
-    def _has_hedge(self, text: str) -> bool:
-        """Check if text already contains hedging language."""
-        text_lower = text.lower()
-        for prefix in self.HEDGE_PREFIXES:
-            if text_lower.startswith(prefix.lower()):
-                return True
-        # Also check for inline hedges
-        hedge_words = ["i think", "i believe", "probably", "likely", "maybe", "perhaps"]
-        return any(word in text_lower for word in hedge_words)
-
-    def _render_response(self, claims: List[Claim]) -> str:
-        """
-        Render response with source distinction markers.
-
-        Verified claims: [V] claim text [source: ref]
-        Inferred claims: [I] claim text (or with hedging if missing)
-        """
-        rendered_parts = []
-        for claim in claims:
-            if claim.source_type == "verified":
-                part = f"[V] {claim.text}"
-                if claim.source_ref:
-                    part += f" [source: {claim.source_ref}]"
-            else:  # inferred
-                if not claim.hedged:
-                    # Add hedging if missing
-                    hedged_text = f"I think {claim.text[0].lower()}{claim.text[1:]}" if claim.text else claim.text
-                    part = f"[I] {hedged_text}"
-                else:
-                    part = f"[I] {claim.text}"
-            rendered_parts.append(part)
-        return " ".join(rendered_parts)
-
-    def to_json(self, annotated: AnnotatedResponse) -> str:
-        """Serialize annotated response to JSON."""
-        return json.dumps(
-            {
-                "original_text": annotated.original_text,
-                "rendered_text": annotated.rendered_text,
-                "has_unverified": annotated.has_unverified,
-                "claims": [asdict(c) for c in annotated.claims],
-            },
-            indent=2,
-            ensure_ascii=False,
-        )

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()

tests/timmy/test_claim_annotator.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for claim_annotator.py — verifies source distinction is present."""
-
-import sys
-import os
-import json
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
-
-from timmy.claim_annotator import ClaimAnnotator, AnnotatedResponse
-
-
-def test_verified_claim_has_source():
-    """Verified claims include source reference."""
-    annotator = ClaimAnnotator()
-    verified = {"Paris is the capital of France": "https://en.wikipedia.org/wiki/Paris"}
-    response = "Paris is the capital of France. It is a beautiful city."
-
-    result = annotator.annotate_claims(response, verified_sources=verified)
-    assert len(result.claims) > 0
-    verified_claims = [c for c in result.claims if c.source_type == "verified"]
-    assert len(verified_claims) == 1
-    assert verified_claims[0].source_ref == "https://en.wikipedia.org/wiki/Paris"
-    assert "[V]" in result.rendered_text
-    assert "[source:" in result.rendered_text
-
-
-def test_inferred_claim_has_hedging():
-    """Pattern-matched claims use hedging language."""
-    annotator = ClaimAnnotator()
-    response = "The weather is nice today. It might rain tomorrow."
-
-    result = annotator.annotate_claims(response)
-    inferred_claims = [c for c in result.claims if c.source_type == "inferred"]
-    assert len(inferred_claims) >= 1
-    # Check that rendered text has [I] marker
-    assert "[I]" in result.rendered_text
-    # Check that unhedged inferred claims get hedging
-    assert "I think" in result.rendered_text or "I believe" in result.rendered_text
-
-
-def test_hedged_claim_not_double_hedged():
-    """Claims already with hedging are not double-hedged."""
-    annotator = ClaimAnnotator()
-    response = "I think the sky is blue. It is a nice day."
-
-    result = annotator.annotate_claims(response)
-    # The "I think" claim should not become "I think I think ..."
-    assert "I think I think" not in result.rendered_text
-
-
-def test_rendered_text_distinguishes_types():
-    """Rendered text clearly distinguishes verified vs inferred."""
-    annotator = ClaimAnnotator()
-    verified = {"Earth is round": "https://science.org/earth"}
-    response = "Earth is round. Stars are far away."
-
-    result = annotator.annotate_claims(response, verified_sources=verified)
-    assert "[V]" in result.rendered_text  # verified marker
-    assert "[I]" in result.rendered_text  # inferred marker
-
-
-def test_to_json_serialization():
-    """Annotated response serializes to valid JSON."""
-    annotator = ClaimAnnotator()
-    response = "Test claim."
-    result = annotator.annotate_claims(response)
-    json_str = annotator.to_json(result)
-    parsed = json.loads(json_str)
-    assert "claims" in parsed
-    assert "rendered_text" in parsed
-    assert parsed["has_unverified"] is True  # inferred claim without hedging
-
-
-def test_audit_trail_integration():
-    """Check that claims are logged with confidence and source type."""
-    # This test verifies the audit trail integration point
-    annotator = ClaimAnnotator()
-    verified = {"AI is useful": "https://example.com/ai"}
-    response = "AI is useful. It can help with tasks."
-
-    result = annotator.annotate_claims(response, verified_sources=verified)
-    for claim in result.claims:
-        assert claim.source_type in ("verified", "inferred")
-        assert claim.confidence in ("high", "medium", "low", "unknown")
-        if claim.source_type == "verified":
-            assert claim.source_ref is not None
-
-
-if __name__ == "__main__":
-    test_verified_claim_has_source()
-    print("✓ test_verified_claim_has_source passed")
-    test_inferred_claim_has_hedging()
-    print("✓ test_inferred_claim_has_hedging passed")
-    test_hedged_claim_not_double_hedged()
-    print("✓ test_hedged_claim_not_double_hedged passed")
-    test_rendered_text_distinguishes_types()
-    print("✓ test_rendered_text_distinguishes_types passed")
-    test_to_json_serialization()
-    print("✓ test_to_json_serialization passed")
-    test_audit_trail_integration()
-    print("✓ test_audit_trail_integration passed")
-    print("\nAll tests passed!")