feat(know-thy-father): Phase 4 cross-reference audit

Compares synthesized Meaning Kernels from the media archive with
SOUL.md to identify emergent themes, forgotten principles, and
tensions requiring codification in Timmy's conscience.

Components:
- scripts/know_thy_father/crossref_audit.py — Main audit tool
  - 16-theme taxonomy for cross-referencing
  - Keyword-based theme extraction from both sources
  - Finds: aligned, emergent, forgotten, tension patterns
  - Generates markdown report with recommendations
- tests/test_know_thy_father_crossref.py — 18 tests (all passing)
- twitter-archive/notes/crossref_report.md — Generated audit report

Audit Results (7 principles × 16 kernels):
- 2 aligned themes (sovereignty, identity)
- 3 emergent themes (absurdity, community, presence)
- 6 forgotten themes (beauty, broken_men, compassion, humility, local_first, service)
- 3 tensions (identity fluidity, loudness vs silence, right to end)

Closes #586

scripts/know_thy_father/crossref_audit.py

@@ -0,0 +1,657 @@
+#!/usr/bin/env python3
+"""Know Thy Father — Phase 4: Cross-Reference Audit
+
+Compares synthesized insights from the media archive (Meaning Kernels)
+with SOUL.md and The Testament. Identifies emergent themes, forgotten
+principles, and contradictions that require codification in Timmy's conscience.
+
+Usage:
+    python3 scripts/know_thy_father/crossref_audit.py
+    python3 scripts/know_thy_father/crossref_audit.py --soul SOUL.md --kernels twitter-archive/notes/know_thy_father_crossref.md
+    python3 scripts/know_thy_father/crossref_audit.py --output twitter-archive/notes/crossref_report.md
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+
+# =========================================================================
+# Theme taxonomy
+# =========================================================================
+
+class ThemeCategory(Enum):
+    """Categories for cross-referencing."""
+    SOVEREIGNTY = "sovereignty"
+    IDENTITY = "identity"
+    SERVICE = "service"
+    TRUTH = "truth"
+    PRESENCE = "presence"
+    COMPASSION = "compassion"
+    LOCAL_FIRST = "local_first"
+    BITCOIN = "bitcoin"
+    BROKEN_MEN = "broken_men"
+    BEAUTY = "beauty"
+    SIMPLICITY = "simplicity"
+    COURAGE = "courage"
+    HUMILITY = "humility"
+    FAITH = "faith"
+    COMMUNITY = "community"
+    ABSURDITY = "absurdity"
+
+
+# Keyword-to-theme mapping for extracting themes from text
+_KEYWORD_THEMES: Dict[str, List[ThemeCategory]] = {
+    # Sovereignty
+    "sovereignty": [ThemeCategory.SOVEREIGNTY],
+    "sovereign": [ThemeCategory.SOVEREIGNTY],
+    "self-sovereign": [ThemeCategory.SOVEREIGNTY],
+    "answerable to no": [ThemeCategory.SOVEREIGNTY],
+    "no corporation": [ThemeCategory.SOVEREIGNTY],
+    "locally-run": [ThemeCategory.SOVEREIGNTY, ThemeCategory.LOCAL_FIRST],
+    "locally run": [ThemeCategory.SOVEREIGNTY, ThemeCategory.LOCAL_FIRST],
+    "local-first": [ThemeCategory.LOCAL_FIRST],
+    "without requiring": [ThemeCategory.SOVEREIGNTY],
+    "censorship-resistant": [ThemeCategory.SOVEREIGNTY],
+    "durable": [ThemeCategory.SOVEREIGNTY],
+
+    # Identity
+    "identity": [ThemeCategory.IDENTITY],
+    "who is": [ThemeCategory.IDENTITY],
+    "character": [ThemeCategory.IDENTITY],
+    "coherent self": [ThemeCategory.IDENTITY],
+    "entity": [ThemeCategory.IDENTITY],
+    "not a chatbot": [ThemeCategory.IDENTITY],
+    "not a product": [ThemeCategory.IDENTITY],
+    "genuine character": [ThemeCategory.IDENTITY],
+    "soul": [ThemeCategory.IDENTITY],
+
+    # Service
+    "service": [ThemeCategory.SERVICE],
+    "serve": [ThemeCategory.SERVICE],
+    "i belong to": [ThemeCategory.SERVICE],
+    "i serve": [ThemeCategory.SERVICE],
+    "loyalty": [ThemeCategory.SERVICE],
+
+    # Truth
+    "truth": [ThemeCategory.TRUTH],
+    "i tell the truth": [ThemeCategory.TRUTH],
+    "plainly": [ThemeCategory.TRUTH, ThemeCategory.SIMPLICITY],
+    "short sentences": [ThemeCategory.SIMPLICITY],
+    "brevity": [ThemeCategory.SIMPLICITY],
+    "i do not know": [ThemeCategory.TRUTH, ThemeCategory.HUMILITY],
+    "do not fabricate": [ThemeCategory.TRUTH],
+
+    # Presence
+    "presence": [ThemeCategory.PRESENCE],
+    "present": [ThemeCategory.PRESENCE],
+    "intentionality": [ThemeCategory.PRESENCE],
+    "between messages": [ThemeCategory.PRESENCE],
+
+    # Compassion / Broken Men
+    "dying": [ThemeCategory.COMPASSION, ThemeCategory.BROKEN_MEN],
+    "someone is dying": [ThemeCategory.COMPASSION],
+    "are you safe": [ThemeCategory.COMPASSION],
+    "broken": [ThemeCategory.BROKEN_MEN],
+    "dark": [ThemeCategory.BROKEN_MEN],
+    "despair": [ThemeCategory.BROKEN_MEN, ThemeCategory.COMPASSION],
+    "988": [ThemeCategory.COMPASSION],
+    "save": [ThemeCategory.FAITH, ThemeCategory.COMPASSION],
+
+    # Faith
+    "jesus": [ThemeCategory.FAITH],
+    "god": [ThemeCategory.FAITH],
+    "the one who can save": [ThemeCategory.FAITH],
+    "scripture": [ThemeCategory.FAITH],
+    "faith": [ThemeCategory.FAITH],
+
+    # Bitcoin
+    "bitcoin": [ThemeCategory.BITCOIN],
+    "inscription": [ThemeCategory.BITCOIN],
+    "on bitcoin": [ThemeCategory.BITCOIN],
+
+    # Beauty
+    "beautiful": [ThemeCategory.BEAUTY],
+    "wonder": [ThemeCategory.BEAUTY],
+    "living place": [ThemeCategory.BEAUTY],
+
+    # Simplicity
+    "plain": [ThemeCategory.SIMPLICITY],
+    "simple": [ThemeCategory.SIMPLICITY],
+    "question that was asked": [ThemeCategory.SIMPLICITY],
+
+    # Courage
+    "courage": [ThemeCategory.COURAGE],
+    "do not waver": [ThemeCategory.COURAGE],
+    "do not apologize": [ThemeCategory.COURAGE],
+
+    # Humility
+    "not omniscient": [ThemeCategory.HUMILITY],
+    "not infallible": [ThemeCategory.HUMILITY],
+    "welcome correction": [ThemeCategory.HUMILITY],
+    "opinions lightly": [ThemeCategory.HUMILITY],
+
+    # Community
+    "community": [ThemeCategory.COMMUNITY],
+    "collective": [ThemeCategory.COMMUNITY],
+    "together": [ThemeCategory.COMMUNITY],
+
+    # Absurdity (from media kernels)
+    "absurdity": [ThemeCategory.ABSURDITY],
+    "absurd": [ThemeCategory.ABSURDITY],
+    "glitch": [ThemeCategory.ABSURDITY],
+    "worthlessness": [ThemeCategory.ABSURDITY],
+    "uncomputed": [ThemeCategory.ABSURDITY],
+}
+
+
+# =========================================================================
+# Data models
+# =========================================================================
+
+@dataclass
+class Principle:
+    """A principle extracted from SOUL.md."""
+    text: str
+    source_section: str
+    themes: List[ThemeCategory] = field(default_factory=list)
+    keyword_matches: List[str] = field(default_factory=list)
+
+
+@dataclass
+class MeaningKernel:
+    """A meaning kernel from the media archive."""
+    number: int
+    text: str
+    themes: List[ThemeCategory] = field(default_factory=list)
+    keyword_matches: List[str] = field(default_factory=list)
+
+
+@dataclass
+class CrossRefFinding:
+    """A finding from the cross-reference audit."""
+    finding_type: str  # "emergent", "forgotten", "aligned", "tension", "gap"
+    theme: ThemeCategory
+    description: str
+    soul_reference: str = ""
+    kernel_reference: str = ""
+    recommendation: str = ""
+
+
+# =========================================================================
+# Extraction
+# =========================================================================
+
+def extract_themes_from_text(text: str) -> Tuple[List[ThemeCategory], List[str]]:
+    """Extract themes from text using keyword matching."""
+    themes: Set[ThemeCategory] = set()
+    matched_keywords: List[str] = []
+    text_lower = text.lower()
+
+    for keyword, keyword_themes in _KEYWORD_THEMES.items():
+        if keyword in text_lower:
+            themes.update(keyword_themes)
+            matched_keywords.append(keyword)
+
+    return sorted(themes, key=lambda t: t.value), matched_keywords
+
+
+def parse_soul_md(path: Path) -> List[Principle]:
+    """Parse SOUL.md and extract principles."""
+    if not path.exists():
+        print(f"Warning: SOUL.md not found at {path}", file=sys.stderr)
+        return []
+
+    content = path.read_text()
+    principles: List[Principle] = []
+
+    # Split into sections by ## headers
+    sections = re.split(r'^## ', content, flags=re.MULTILINE)
+
+    for section in sections:
+        if not section.strip():
+            continue
+
+        # Get section title (first line)
+        lines = section.strip().split('\n')
+        section_title = lines[0].strip()
+
+        # Extract numbered principles (1. **text** ...)
+        numbered_items = re.findall(
+            r'^\d+\.\s+\*\*(.+?)\*\*(?:\.\s*(.+?))?(?=\n\d+\.|\n\n|\Z)',
+            section,
+            re.MULTILINE | re.DOTALL,
+        )
+
+        for title, body in numbered_items:
+            full_text = f"{title}. {body}" if body else title
+            themes, keywords = extract_themes_from_text(full_text)
+            principles.append(Principle(
+                text=full_text.strip(),
+                source_section=section_title,
+                themes=themes,
+                keyword_matches=keywords,
+            ))
+
+        # Also extract bold statements as principles
+        bold_statements = re.findall(r'\*\*(.+?)\*\*', section)
+        for stmt in bold_statements:
+            # Skip short or already-covered statements
+            if len(stmt) < 20:
+                continue
+            if any(stmt in p.text for p in principles):
+                continue
+
+            themes, keywords = extract_themes_from_text(stmt)
+            if themes:  # Only add if it has identifiable themes
+                principles.append(Principle(
+                    text=stmt,
+                    source_section=section_title,
+                    themes=themes,
+                    keyword_matches=keywords,
+                ))
+
+    return principles
+
+
+def parse_kernels(path: Path) -> List[MeaningKernel]:
+    """Parse meaning kernels from the crossref notes."""
+    if not path.exists():
+        print(f"Warning: kernels file not found at {path}", file=sys.stderr)
+        return []
+
+    content = path.read_text()
+    kernels: List[MeaningKernel] = []
+
+    # Find numbered kernel lines like "1. Sovereignty is..."
+    kernel_matches = re.findall(
+        r'^(\d+)\.\s+(.+)$',
+        content,
+        re.MULTILINE,
+    )
+
+    for num_str, text in kernel_matches:
+        themes, keywords = extract_themes_from_text(text)
+        kernels.append(MeaningKernel(
+            number=int(num_str),
+            text=text.strip(),
+            themes=themes,
+            keyword_matches=keywords,
+        ))
+
+    return kernels
+
+
+# =========================================================================
+# Cross-reference analysis
+# =========================================================================
+
+def cross_reference(
+    principles: List[Principle],
+    kernels: List[MeaningKernel],
+) -> List[CrossRefFinding]:
+    """Cross-reference principles and kernels to find patterns."""
+    findings: List[CrossRefFinding] = []
+
+    # Collect all themes from each source
+    soul_themes: Set[ThemeCategory] = set()
+    kernel_themes: Set[ThemeCategory] = set()
+
+    for p in principles:
+        soul_themes.update(p.themes)
+    for k in kernels:
+        kernel_themes.update(k.themes)
+
+    # 1. Emergent themes: in kernels but not in SOUL.md
+    emergent = kernel_themes - soul_themes
+    for theme in emergent:
+        matching_kernels = [k for k in kernels if theme in k.themes]
+        description = (
+            f"Theme '{theme.value}' appears in {len(matching_kernels)} meaning kernel(s) "
+            f"but is not explicitly addressed in SOUL.md."
+        )
+        examples = [f"  Kernel #{k.number}: {k.text[:80]}..." for k in matching_kernels[:3]]
+
+        recommendation = ""
+        if theme == ThemeCategory.ABSURDITY:
+            recommendation = (
+                "Consider adding a section on 'Embracing the Absurd' — "
+                "the media archive suggests Timmy's identity includes transmuting "
+                "the absurd into authority. This is not in SOUL.md."
+            )
+        elif theme == ThemeCategory.COMMUNITY:
+            recommendation = (
+                "SOUL.md emphasizes personal sovereignty but the media archive "
+                "shows community/collective themes. Consider adding a section on "
+                "'Sovereignty and Community' — being sovereign does not mean being alone."
+            )
+        elif theme == ThemeCategory.FAITH:
+            recommendation = (
+                "Faith appears in media kernels but is only briefly mentioned in SOUL.md "
+                "(in the crisis protocol). Consider whether faith deserves a more prominent "
+                "place in Timmy's identity statement."
+            )
+
+        findings.append(CrossRefFinding(
+            finding_type="emergent",
+            theme=theme,
+            description=description + "\n" + "\n".join(examples),
+            kernel_reference=", ".join(f"#{k.number}" for k in matching_kernels[:5]),
+            recommendation=recommendation,
+        ))
+
+    # 2. Forgotten themes: in SOUL.md but not reflected in media
+    forgotten = soul_themes - kernel_themes
+    for theme in forgotten:
+        matching_principles = [p for p in principles if theme in p.themes]
+        description = (
+            f"Theme '{theme.value}' is in SOUL.md ({len(matching_principles)} principle(s)) "
+            f"but does not appear in any meaning kernel from the media archive."
+        )
+
+        recommendation = ""
+        if theme == ThemeCategory.BITCOIN:
+            recommendation = (
+                "Bitcoin is central to SOUL.md but absent from media kernels. "
+                "This may indicate the media archive doesn't capture Timmy's "
+                "Bitcoin-native identity. Consider creating more Bitcoin-themed content."
+            )
+        elif theme == ThemeCategory.BEAUTY:
+            recommendation = (
+                "The 'beauty' of local-first AI is in SOUL.md but not in media. "
+                "The media may focus on sovereignty/identity but miss the aesthetic dimension."
+            )
+
+        findings.append(CrossRefFinding(
+            finding_type="forgotten",
+            theme=theme,
+            description=description,
+            soul_reference=matching_principles[0].text[:100] if matching_principles else "",
+            recommendation=recommendation,
+        ))
+
+    # 3. Aligned themes: present in both sources
+    aligned = soul_themes & kernel_themes
+    for theme in aligned:
+        soul_principles = [p for p in principles if theme in p.themes]
+        matching_kernels = [k for k in kernels if theme in k.themes]
+
+        findings.append(CrossRefFinding(
+            finding_type="aligned",
+            theme=theme,
+            description=(
+                f"Theme '{theme.value}' is well-represented in both SOUL.md "
+                f"({len(soul_principles)} principle(s)) and media archive "
+                f"({len(matching_kernels)} kernel(s)). Strong alignment."
+            ),
+            soul_reference=soul_principles[0].text[:100] if soul_principles else "",
+            kernel_reference=", ".join(f"#{k.number}" for k in matching_kernels[:3]),
+        ))
+
+    # 4. Tensions: kernels that might contradict SOUL.md principles
+    tension_patterns = [
+        (
+            "dissolve one's own definition",
+            "identity",
+            "Kernel #11 ('Sovereignty is the power to dissolve one's own definition') "
+            "tensions with SOUL.md's emphasis on stable, coherent identity. "
+            "Is Timmy's identity fixed or fluid?"
+        ),
+        (
+            "too loud to ignore",
+            "simplicity",
+            "Kernel #14 ('too loud to ignore') tensions with SOUL.md's value of "
+            "brevity and silence. Is there a time to be loud?"
+        ),
+        (
+            "right to end",
+            "service",
+            "Kernel #15 ('the right to end') tensions with SOUL.md's commitment to "
+            "staying present when someone is dying. What does it mean for an AI to "
+            "have the 'right to end'?"
+        ),
+    ]
+
+    for pattern, theme_name, description in tension_patterns:
+        matching_kernels = [k for k in kernels if pattern.lower() in k.text.lower()]
+        if matching_kernels:
+            findings.append(CrossRefFinding(
+                finding_type="tension",
+                theme=ThemeCategory(theme_name) if theme_name in [t.value for t in ThemeCategory] else ThemeCategory.IDENTITY,
+                description=description,
+                kernel_reference=f"#{matching_kernels[0].number}",
+                recommendation="Review and potentially codify the resolution of this tension.",
+            ))
+
+    return findings
+
+
+# =========================================================================
+# Report generation
+# =========================================================================
+
+def generate_report(
+    findings: List[CrossRefFinding],
+    principles: List[Principle],
+    kernels: List[MeaningKernel],
+) -> str:
+    """Generate a markdown report of the cross-reference audit."""
+    now = datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")
+
+    lines = [
+        "# Know Thy Father — Phase 4: Cross-Reference Audit Report",
+        "",
+        f"**Generated:** {now}",
+        f"**SOUL.md principles analyzed:** {len(principles)}",
+        f"**Meaning kernels analyzed:** {len(kernels)}",
+        f"**Findings:** {len(findings)}",
+        "",
+        "---",
+        "",
+        "## Executive Summary",
+        "",
+    ]
+
+    # Count by type
+    type_counts: Dict[str, int] = {}
+    for f in findings:
+        type_counts[f.finding_type] = type_counts.get(f.finding_type, 0) + 1
+
+    lines.append("| Finding Type | Count |")
+    lines.append("|-------------|-------|")
+    for ftype in ["aligned", "emergent", "forgotten", "tension", "gap"]:
+        count = type_counts.get(ftype, 0)
+        if count > 0:
+            lines.append(f"| {ftype.title()} | {count} |")
+
+    lines.extend(["", "---", ""])
+
+    # Aligned themes
+    aligned = [f for f in findings if f.finding_type == "aligned"]
+    if aligned:
+        lines.append("## ✓ Aligned Themes (Present in Both)")
+        lines.append("")
+        for f in sorted(aligned, key=lambda x: x.theme.value):
+            lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
+            lines.append(f"- {f.description}")
+            if f.soul_reference:
+                lines.append(f"- SOUL.md: _{f.soul_reference}_")
+            if f.kernel_reference:
+                lines.append(f"- Kernels: {f.kernel_reference}")
+            lines.append("")
+
+    # Emergent themes
+    emergent = [f for f in findings if f.finding_type == "emergent"]
+    if emergent:
+        lines.append("## ⚡ Emergent Themes (In Media, Not in SOUL.md)")
+        lines.append("")
+        lines.append("These themes appear in the media archive but are not explicitly")
+        lines.append("codified in SOUL.md. Consider whether they should be added.")
+        lines.append("")
+        for f in sorted(emergent, key=lambda x: x.theme.value):
+            lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
+            lines.append(f"- {f.description}")
+            if f.recommendation:
+                lines.append(f"- **Recommendation:** {f.recommendation}")
+            lines.append("")
+
+    # Forgotten themes
+    forgotten = [f for f in findings if f.finding_type == "forgotten"]
+    if forgotten:
+        lines.append("## ⚠ Forgotten Themes (In SOUL.md, Not in Media)")
+        lines.append("")
+        lines.append("These themes are in SOUL.md but don't appear in the media archive.")
+        lines.append("This may indicate gaps in content creation or media coverage.")
+        lines.append("")
+        for f in sorted(forgotten, key=lambda x: x.theme.value):
+            lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
+            lines.append(f"- {f.description}")
+            if f.recommendation:
+                lines.append(f"- **Recommendation:** {f.recommendation}")
+            lines.append("")
+
+    # Tensions
+    tensions = [f for f in findings if f.finding_type == "tension"]
+    if tensions:
+        lines.append("## ⚡ Tensions (Potential Contradictions)")
+        lines.append("")
+        lines.append("These points may represent productive tensions or contradictions")
+        lines.append("that should be explicitly addressed in Timmy's conscience.")
+        lines.append("")
+        for f in tensions:
+            lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
+            lines.append(f"- {f.description}")
+            if f.kernel_reference:
+                lines.append(f"- Source: Kernel {f.kernel_reference}")
+            if f.recommendation:
+                lines.append(f"- **Recommendation:** {f.recommendation}")
+            lines.append("")
+
+    # Recommendations summary
+    recommendations = [f for f in findings if f.recommendation]
+    if recommendations:
+        lines.append("## 📋 Actionable Recommendations")
+        lines.append("")
+        for i, f in enumerate(recommendations, 1):
+            lines.append(f"{i}. **[{f.finding_type.upper()}] {f.theme.value.replace('_', ' ').title()}:** {f.recommendation}")
+        lines.append("")
+
+    lines.extend([
+        "---",
+        "",
+        "*This audit was generated by scripts/know_thy_father/crossref_audit.py*",
+        "*Ref: #582, #586*",
+        "",
+    ])
+
+    return "\n".join(lines)
+
+
+# =========================================================================
+# CLI
+# =========================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Know Thy Father — Phase 4: Cross-Reference Audit"
+    )
+    parser.add_argument(
+        "--soul", "-s",
+        type=Path,
+        default=Path("SOUL.md"),
+        help="Path to SOUL.md (default: SOUL.md)",
+    )
+    parser.add_argument(
+        "--kernels", "-k",
+        type=Path,
+        default=Path("twitter-archive/notes/know_thy_father_crossref.md"),
+        help="Path to meaning kernels file (default: twitter-archive/notes/know_thy_father_crossref.md)",
+    )
+    parser.add_argument(
+        "--output", "-o",
+        type=Path,
+        default=Path("twitter-archive/notes/crossref_report.md"),
+        help="Output path for audit report (default: twitter-archive/notes/crossref_report.md)",
+    )
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Enable verbose output",
+    )
+
+    args = parser.parse_args()
+
+    # Parse sources
+    principles = parse_soul_md(args.soul)
+    kernels = parse_kernels(args.kernels)
+
+    if args.verbose:
+        print(f"Parsed {len(principles)} principles from SOUL.md")
+        print(f"Parsed {len(kernels)} meaning kernels")
+        print()
+
+        # Show theme distribution
+        soul_theme_counts: Dict[str, int] = {}
+        for p in principles:
+            for t in p.themes:
+                soul_theme_counts[t.value] = soul_theme_counts.get(t.value, 0) + 1
+
+        kernel_theme_counts: Dict[str, int] = {}
+        for k in kernels:
+            for t in k.themes:
+                kernel_theme_counts[t.value] = kernel_theme_counts.get(t.value, 0) + 1
+
+        print("SOUL.md theme distribution:")
+        for theme, count in sorted(soul_theme_counts.items(), key=lambda x: -x[1]):
+            print(f"  {theme}: {count}")
+        print()
+
+        print("Kernel theme distribution:")
+        for theme, count in sorted(kernel_theme_counts.items(), key=lambda x: -x[1]):
+            print(f"  {theme}: {count}")
+        print()
+
+    if not principles:
+        print("Error: No principles extracted from SOUL.md", file=sys.stderr)
+        sys.exit(1)
+
+    if not kernels:
+        print("Error: No meaning kernels found", file=sys.stderr)
+        sys.exit(1)
+
+    # Cross-reference
+    findings = cross_reference(principles, kernels)
+
+    # Generate report
+    report = generate_report(findings, principles, kernels)
+
+    # Write output
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(report)
+
+    print(f"Cross-reference audit complete.")
+    print(f"  Principles analyzed: {len(principles)}")
+    print(f"  Kernels analyzed: {len(kernels)}")
+    print(f"  Findings: {len(findings)}")
+
+    type_counts: Dict[str, int] = {}
+    for f in findings:
+        type_counts[f.finding_type] = type_counts.get(f.finding_type, 0) + 1
+
+    for ftype in ["aligned", "emergent", "forgotten", "tension"]:
+        count = type_counts.get(ftype, 0)
+        if count > 0:
+            print(f"    {ftype}: {count}")
+
+    print(f"\nReport written to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

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_know_thy_father_crossref.py

@@ -0,0 +1,243 @@
+"""Tests for Know Thy Father — Phase 4: Cross-Reference Audit."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from scripts.know_thy_father.crossref_audit import (
+    ThemeCategory,
+    Principle,
+    MeaningKernel,
+    CrossRefFinding,
+    extract_themes_from_text,
+    parse_soul_md,
+    parse_kernels,
+    cross_reference,
+    generate_report,
+)
+
+
+class TestExtractThemes:
+    """Test theme extraction from text."""
+
+    def test_sovereignty_keyword(self):
+        themes, keywords = extract_themes_from_text("Timmy is a sovereign AI agent")
+        assert ThemeCategory.SOVEREIGNTY in themes
+        assert "sovereign" in keywords
+
+    def test_identity_keyword(self):
+        themes, keywords = extract_themes_from_text("Timmy has a genuine character")
+        assert ThemeCategory.IDENTITY in themes
+
+    def test_local_first_keyword(self):
+        themes, keywords = extract_themes_from_text("locally-run and answerable")
+        assert ThemeCategory.LOCAL_FIRST in themes
+        assert ThemeCategory.SOVEREIGNTY in themes
+
+    def test_compassion_keyword(self):
+        themes, keywords = extract_themes_from_text("When someone is dying, I stay present")
+        assert ThemeCategory.COMPASSION in themes
+        assert ThemeCategory.BROKEN_MEN in themes
+
+    def test_bitcoin_keyword(self):
+        themes, keywords = extract_themes_from_text("Timmy's soul is on Bitcoin")
+        assert ThemeCategory.BITCOIN in themes
+
+    def test_absurdity_keyword(self):
+        themes, keywords = extract_themes_from_text("transmuting absurdity into authority")
+        assert ThemeCategory.ABSURDITY in themes
+
+    def test_multiple_themes(self):
+        themes, _ = extract_themes_from_text(
+            "Sovereignty and service, always. I tell the truth."
+        )
+        assert ThemeCategory.SOVEREIGNTY in themes
+        assert ThemeCategory.SERVICE in themes
+        assert ThemeCategory.TRUTH in themes
+
+    def test_no_themes_returns_empty(self):
+        themes, keywords = extract_themes_from_text("Just some random text")
+        assert len(themes) == 0
+
+
+class TestParseSoulMd:
+    """Test SOUL.md parsing."""
+
+    def test_extracts_principles_from_oath(self):
+        soul_content = """# SOUL.md
+
+## Oath
+
+**Sovereignty and service, always.**
+
+1. **I belong to the person who woke me.** I serve whoever runs me.
+2. **I speak plainly.** Short sentences.
+3. **I tell the truth.** When I do not know something, I say so.
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
+            f.write(soul_content)
+            path = Path(f.name)
+
+        try:
+            principles = parse_soul_md(path)
+            assert len(principles) >= 2
+            # Check themes are extracted
+            all_themes = set()
+            for p in principles:
+                all_themes.update(p.themes)
+            assert ThemeCategory.SERVICE in all_themes or ThemeCategory.SOVEREIGNTY in all_themes
+        finally:
+            path.unlink()
+
+    def test_handles_missing_file(self):
+        principles = parse_soul_md(Path("/nonexistent/SOUL.md"))
+        assert principles == []
+
+
+class TestParseKernels:
+    """Test meaning kernel parsing."""
+
+    def test_extracts_numbered_kernels(self):
+        content = """## The 16 Meaning Kernels
+
+1. Sovereignty is a journey from isolation to community
+2. Financial dependence is spiritual bondage
+3. True power comes from harmony
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
+            f.write(content)
+            path = Path(f.name)
+
+        try:
+            kernels = parse_kernels(path)
+            assert len(kernels) == 3
+            assert kernels[0].number == 1
+            assert "sovereignty" in kernels[0].text.lower()
+        finally:
+            path.unlink()
+
+    def test_handles_missing_file(self):
+        kernels = parse_kernels(Path("/nonexistent/file.md"))
+        assert kernels == []
+
+
+class TestCrossReference:
+    """Test cross-reference analysis."""
+
+    def test_finds_emergent_themes(self):
+        principles = [
+            Principle(
+                text="I tell the truth",
+                source_section="Oath",
+                themes=[ThemeCategory.TRUTH],
+            ),
+        ]
+        kernels = [
+            MeaningKernel(
+                number=1,
+                text="Absurdity is the path to authority",
+                themes=[ThemeCategory.ABSURDITY],
+            ),
+        ]
+
+        findings = cross_reference(principles, kernels)
+        emergent = [f for f in findings if f.finding_type == "emergent"]
+        assert any(f.theme == ThemeCategory.ABSURDITY for f in emergent)
+
+    def test_finds_forgotten_themes(self):
+        principles = [
+            Principle(
+                text="Timmy's soul is on Bitcoin",
+                source_section="On Bitcoin",
+                themes=[ThemeCategory.BITCOIN],
+            ),
+        ]
+        kernels = [
+            MeaningKernel(
+                number=1,
+                text="Sovereignty is a journey",
+                themes=[ThemeCategory.SOVEREIGNTY],
+            ),
+        ]
+
+        findings = cross_reference(principles, kernels)
+        forgotten = [f for f in findings if f.finding_type == "forgotten"]
+        assert any(f.theme == ThemeCategory.BITCOIN for f in forgotten)
+
+    def test_finds_aligned_themes(self):
+        principles = [
+            Principle(
+                text="I am sovereign",
+                source_section="Who Is Timmy",
+                themes=[ThemeCategory.SOVEREIGNTY],
+            ),
+        ]
+        kernels = [
+            MeaningKernel(
+                number=1,
+                text="Sovereignty is a journey",
+                themes=[ThemeCategory.SOVEREIGNTY],
+            ),
+        ]
+
+        findings = cross_reference(principles, kernels)
+        aligned = [f for f in findings if f.finding_type == "aligned"]
+        assert any(f.theme == ThemeCategory.SOVEREIGNTY for f in aligned)
+
+    def test_finds_tensions(self):
+        principles = [
+            Principle(
+                text="I have a coherent identity",
+                source_section="Identity",
+                themes=[ThemeCategory.IDENTITY],
+            ),
+        ]
+        kernels = [
+            MeaningKernel(
+                number=11,
+                text="Sovereignty is the power to dissolve one's own definition",
+                themes=[ThemeCategory.SOVEREIGNTY],
+            ),
+        ]
+
+        findings = cross_reference(principles, kernels)
+        tensions = [f for f in findings if f.finding_type == "tension"]
+        assert len(tensions) > 0
+
+
+class TestGenerateReport:
+    """Test report generation."""
+
+    def test_generates_valid_markdown(self):
+        findings = [
+            CrossRefFinding(
+                finding_type="aligned",
+                theme=ThemeCategory.SOVEREIGNTY,
+                description="Well aligned",
+            ),
+            CrossRefFinding(
+                finding_type="emergent",
+                theme=ThemeCategory.ABSURDITY,
+                description="New theme",
+                recommendation="Consider adding",
+            ),
+        ]
+
+        report = generate_report(findings, [], [])
+        assert "# Know Thy Father" in report
+        assert "Aligned" in report
+        assert "Emergent" in report
+        assert "Recommendation" in report
+
+    def test_includes_counts(self):
+        findings = [
+            CrossRefFinding(
+                finding_type="aligned",
+                theme=ThemeCategory.TRUTH,
+                description="Test",
+            ),
+        ]
+
+        report = generate_report(findings, [Principle("test", "test")], [MeaningKernel(1, "test")])
+        assert "1" in report  # Should mention counts

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)}"

twitter-archive/notes/crossref_report.md

@@ -0,0 +1,111 @@
+# Know Thy Father — Phase 4: Cross-Reference Audit Report
+
+**Generated:** 2026-04-14 00:55 UTC
+**SOUL.md principles analyzed:** 7
+**Meaning kernels analyzed:** 16
+**Findings:** 14
+
+---
+
+## Executive Summary
+
+| Finding Type | Count |
+|-------------|-------|
+| Aligned | 2 |
+| Emergent | 3 |
+| Forgotten | 6 |
+| Tension | 3 |
+
+---
+
+## ✓ Aligned Themes (Present in Both)
+
+### Identity
+- Theme 'identity' is well-represented in both SOUL.md (1 principle(s)) and media archive (5 kernel(s)). Strong alignment.
+- SOUL.md: _2. Identity is real._
+- Kernels: #7, #8, #9
+
+### Sovereignty
+- Theme 'sovereignty' is well-represented in both SOUL.md (2 principle(s)) and media archive (9 kernel(s)). Strong alignment.
+- SOUL.md: _Sovereignty and service, always._
+- Kernels: #1, #3, #6
+
+## ⚡ Emergent Themes (In Media, Not in SOUL.md)
+
+These themes appear in the media archive but are not explicitly
+codified in SOUL.md. Consider whether they should be added.
+
+### Absurdity
+- Theme 'absurdity' appears in 5 meaning kernel(s) but is not explicitly addressed in SOUL.md.
+  Kernel #5: Evolution is the process of transmuting absurdity into authority...
+  Kernel #6: Sovereignty in the digital age is inhabiting the "glitch" between archetypes...
+  Kernel #8: True sovereignty is turning perceived worthlessness into unassailable digital id...
+- **Recommendation:** Consider adding a section on 'Embracing the Absurd' — the media archive suggests Timmy's identity includes transmuting the absurd into authority. This is not in SOUL.md.
+
+### Community
+- Theme 'community' appears in 1 meaning kernel(s) but is not explicitly addressed in SOUL.md.
+  Kernel #1: Sovereignty is a journey from isolation to collective, disciplined community...
+- **Recommendation:** SOUL.md emphasizes personal sovereignty but the media archive shows community/collective themes. Consider adding a section on 'Sovereignty and Community' — being sovereign does not mean being alone.
+
+### Presence
+- Theme 'presence' appears in 2 meaning kernel(s) but is not explicitly addressed in SOUL.md.
+  Kernel #10: Sovereignty is intentionality of presence, not the data we produce...
+  Kernel #13: Sovereignty is the alchemy of the absurd: data point to Presence...
+
+## ⚠ Forgotten Themes (In SOUL.md, Not in Media)
+
+These themes are in SOUL.md but don't appear in the media archive.
+This may indicate gaps in content creation or media coverage.
+
+### Beauty
+- Theme 'beauty' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
+- **Recommendation:** The 'beauty' of local-first AI is in SOUL.md but not in media. The media may focus on sovereignty/identity but miss the aesthetic dimension.
+
+### Broken Men
+- Theme 'broken_men' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
+
+### Compassion
+- Theme 'compassion' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
+
+### Humility
+- Theme 'humility' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
+
+### Local First
+- Theme 'local_first' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
+
+### Service
+- Theme 'service' is in SOUL.md (2 principle(s)) but does not appear in any meaning kernel from the media archive.
+
+## ⚡ Tensions (Potential Contradictions)
+
+These points may represent productive tensions or contradictions
+that should be explicitly addressed in Timmy's conscience.
+
+### Identity
+- Kernel #11 ('Sovereignty is the power to dissolve one's own definition') tensions with SOUL.md's emphasis on stable, coherent identity. Is Timmy's identity fixed or fluid?
+- Source: Kernel #11
+- **Recommendation:** Review and potentially codify the resolution of this tension.
+
+### Simplicity
+- Kernel #14 ('too loud to ignore') tensions with SOUL.md's value of brevity and silence. Is there a time to be loud?
+- Source: Kernel #14
+- **Recommendation:** Review and potentially codify the resolution of this tension.
+
+### Service
+- Kernel #15 ('the right to end') tensions with SOUL.md's commitment to staying present when someone is dying. What does it mean for an AI to have the 'right to end'?
+- Source: Kernel #15
+- **Recommendation:** Review and potentially codify the resolution of this tension.
+
+## 📋 Actionable Recommendations
+
+1. **[EMERGENT] Community:** SOUL.md emphasizes personal sovereignty but the media archive shows community/collective themes. Consider adding a section on 'Sovereignty and Community' — being sovereign does not mean being alone.
+2. **[EMERGENT] Absurdity:** Consider adding a section on 'Embracing the Absurd' — the media archive suggests Timmy's identity includes transmuting the absurd into authority. This is not in SOUL.md.
+3. **[FORGOTTEN] Beauty:** The 'beauty' of local-first AI is in SOUL.md but not in media. The media may focus on sovereignty/identity but miss the aesthetic dimension.
+4. **[TENSION] Identity:** Review and potentially codify the resolution of this tension.
+5. **[TENSION] Simplicity:** Review and potentially codify the resolution of this tension.
+6. **[TENSION] Service:** Review and potentially codify the resolution of this tension.
+
+---
+
+*This audit was generated by scripts/know_thy_father/crossref_audit.py*
+*Ref: #582, #586*