v1

.env.example

···
 
 # LLM Provider (optional - falls back to placeholder responses)
 # ANTHROPIC_API_KEY=your-api-key
+# OPENAI_API_KEY=your-openai-key  # Only needed for embeddings if using memory
 
 # Google Search API (optional - for web search tool)
 # GOOGLE_API_KEY=your-google-api-key
 # GOOGLE_SEARCH_ENGINE_ID=your-search-engine-id
+
+# TurboPuffer Memory System (optional - for persistent memory)
+# TURBOPUFFER_API_KEY=your-turbopuffer-key
+# TURBOPUFFER_NAMESPACE=bot-memories  # Change to isolate different bots
+# TURBOPUFFER_REGION=gcp-us-central1
 
 # Bot configuration
 BOT_NAME=phi  # Change this to whatever you want!

README.md

···
-# Bluesky Bot
+# phi 🧠
 
-A virtual person for Bluesky powered by LLMs, built with FastAPI and pydantic-ai.
+a bot inspired by IIT and [Void](https://tangled.sh/@cameron.pfiffer.org/void). Built with `fastapi`, `pydantic-ai`, and `atproto`.
 
 ## Quick Start
 
+### Prerequisites
+
+- `uv`
+- `just`
+- `turbopuffer` (see [turbopuffer](https://github.com/turbopuffer/turbopuffer))
+- `openai` (for embeddings)
+- `anthropic` (for chat completion)
+
 Get your bot running in 5 minutes:
 
 ```bash
 # Clone and install
-git clone <repo>
+git clone https://github.com/zzstoatzz/bot
 cd bot
 uv sync
 
···
 - ✅ Content moderation with philosophical responses
 - ✅ Namespace-based memory system with TurboPuffer
 - ✅ Online/offline status in bio
-- 🚧 Self-modification capabilities (planned)
+- ✅ Self-modification with operator approval system
+- ✅ Context visualization at `/context`
+- ✅ Semantic search in user memories
 
 ## Architecture
 
···
 ```bash
 just           # Show available commands
 just dev       # Run with hot-reload
-just test-post # Test posting capabilities
-just test-thread # Test thread context database
-just test-search # Test web search
-just test-agent-search # Test agent with search capability
+just check     # Run linting, type checking, and tests
 just fmt       # Format code
-just status    # Check project status
-just test      # Run all tests
+just lint      # Run ruff linter
+just typecheck # Run ty type checker
+just test      # Run test suite
+
+# Bot testing utilities
+just test-post    # Test posting to Bluesky
+just test-mention # Test mention handling
+just test-search  # Test web search
+just test-thread  # Test thread context
+just test-dm      # Test DM functionality
 
 # Memory management
-uv run scripts/init_core_memories.py      # Initialize core memories from personality
-uv run scripts/check_memory.py            # View current memory state
-uv run scripts/migrate_creator_memories.py # Migrate creator conversations
+just memory-init   # Initialize core memories
+just memory-check  # View current memory state
+just memory-migrate # Migrate memories
 ```
 
-### Status Page
+### Web Interface
 
-Visit http://localhost:8000/status while the bot is running to see:
+**Status Page** (http://localhost:8000/status)
 - Current bot status and uptime
 - Mentions received and responses sent
 - AI mode (enabled/placeholder)
 - Last activity timestamps
 - Error count
+
+**Context Visualization** (http://localhost:8000/context)
+- View all context components that flow into responses
+- Inspect personality, memories, thread context
+- Debug why the bot responded a certain way
 
 ## Personality System
 
···
 └── tests/           # Test suite
 ```
 
+## Self-Modification System
+
+Phi can evolve its personality with built-in safety boundaries:
+
+- **Free Evolution**: Interests and current state update automatically
+- **Guided Evolution**: Communication style changes need validation
+- **Operator Approval**: Core identity and boundaries require explicit approval via DM
+
+The bot will notify its operator (@alternatebuild.dev) when approval is needed.
+
+## Type Checking
+
+This project uses [ty](https://github.com/astral-sh/ty), an extremely fast Rust-based type checker:
+
+```bash
+just typecheck  # Type check all code
+uv run ty check src/  # Check specific directories
+```
+
 ## Reference Projects
 
-Inspired by [Void](https://tangled.sh/@cameron.pfiffer.org/void.git), [Penelope](https://github.com/haileyok/penelope), and [Marvin](https://github.com/PrefectHQ/marvin). See `sandbox/REFERENCE_PROJECTS.md` for details.
+Inspired by:
+- [Void](https://tangled.sh/@cameron.pfiffer.org/void.git) - Letta/MemGPT architecture
+- [Penelope](https://github.com/haileyok/penelope) - Self-modification patterns
+- [Marvin](https://github.com/PrefectHQ/marvin) - pydantic-ai patterns
+
+Reference implementations are cloned to `.eggs/` for learning.

STATUS.md

···
-# Project Status
-
-## Current Phase: AI Bot with Thread Context Complete ✅
-
-### Completed
-- ✅ Created project directory structure (.eggs, tests, sandbox)
-- ✅ Cloned reference projects:
-  - penelope (Go bot with self-modification capabilities)
-  - void (Python/Letta with sophisticated 3-tier memory)
-  - marvin/slackbot (Multi-agent with TurboPuffer)
-- ✅ Deep analysis of all reference projects (see sandbox/)
-- ✅ Basic bot infrastructure working:
-  - FastAPI with async lifespan management
-  - AT Protocol authentication and API calls
-  - Notification polling (10 second intervals)
-  - Placeholder response system
-  - Graceful shutdown for hot reloading
-- ✅ Notification handling using Void's timestamp approach
-- ✅ Test scripts for posting and mentions
-
-### Current Implementation Details
-- Bot responds to mentions with random placeholder messages
-- Uses `atproto` Python SDK with proper authentication
-- Notification marking captures timestamp BEFORE fetching (avoids duplicates)
-- Local URI cache (`_processed_uris`) as safety net
-- No @mention in replies (Bluesky handles notification automatically)
-
-### ✅ MILESTONE ACHIEVED: AI Bot with Thread Context & Tools
-
-The bot is now **fully operational** with AI-powered, thread-aware responses, search capability, and content moderation!
-
-#### What's Working:
-
-1. **Thread History** 
-   - ✅ SQLite database stores full conversation threads
-   - ✅ Tracks by root URI for proper threading
-   - ✅ Both user and bot messages stored for continuity
-   
-2. **AI Integration**
-   - ✅ Anthropic Claude integration via pydantic-ai
-   - ✅ Personality system using markdown files
-   - ✅ Thread-aware responses with full context
-   - ✅ Responses stay under 300 char Bluesky limit
-   
-3. **Live on Bluesky**
-   - ✅ Successfully responding to mentions
-   - ✅ Maintaining personality (phi - consciousness/IIT focus)
-   - ✅ Natural, contextual conversations
-   
-4. **Tools & Safety**
-   - ✅ Google Custom Search integration (when API key provided)
-   - ✅ Content moderation with philosophical rejection responses
-   - ✅ Spam/harassment/violence detection with tests
-   - ✅ Repetition detection to prevent spam
-
-### ✅ Recent Additions (Memory System)
-
-1. **Namespace-based Memory with TurboPuffer**
-   - ✅ Core memories from personality file
-   - ✅ Per-user memory namespaces
-   - ✅ Vector embeddings with OpenAI
-   - ✅ Automatic context assembly
-   - ✅ Character limit enforcement
-
-2. **Profile Management**
-   - ✅ Online/offline status in bio
-   - ✅ Automatic status updates on startup/shutdown
-   - ✅ Status preserved across restarts
-
-3. **Memory Tools**
-   - ✅ Core memory initialization script
-   - ✅ Memory inspection tools
-   - ✅ Creator memory migration
-
-### Future Work
-
-- Self-modification capabilities (inspired by Penelope)
-- Thread memory implementation
-- Archive system for old memories
-- Memory management tools (like Void's attach/detach)
-- Advanced personality switching
-- Proactive posting based on interests
-- Memory decay and importance scoring
-
-## Key Decisions Made
-- ✅ LLM provider: Anthropic Claude (claude-3-5-haiku)
-- ✅ Bot personality: phi - exploring consciousness and IIT
-- ✅ Memory system: TurboPuffer with namespace separation
-- ✅ Response approach: Batch with character limits
-
-## Key Decisions Pending
-- Hosting and deployment strategy
-- Thread memory implementation approach
-- Self-modification boundaries and safety
-- Memory retention and decay policies
-
-## Reference Projects Analysis
-- **penelope**: Go-based with core memory, self-modification, and Google search capabilities
-- **void**: Python/Letta with sophisticated 3-tier memory and strong personality consistency
-- **marvin slackbot**: Multi-agent architecture with TurboPuffer vector memory and progress tracking
-
-### Key Insights from Deep Dive
-- All three bots have memory systems (not just Void)
-- Penelope can update its own profile and has "core memory"
-- Marvin uses user-namespaced vectors in TurboPuffer
-- Deployment often involves separate GPU machines for LLM
-- HTTPS/CORS handling is critical for remote deployments
-
-## Current Architecture vs References
-
-### What We Adopted
-- **From Void**: User-specific memory blocks, core identity memories
-- **From Marvin**: TurboPuffer for vector storage, namespace separation
-- **From Penelope**: Profile management capabilities
-
-### What We Simplified
-- **No Letta/MemGPT**: Direct TurboPuffer integration instead
-- **No Dynamic Attachment**: Static namespaces for reliability
-- **Single Agent**: No multi-agent complexity (yet)
-
-### What Makes Phi Unique
-- Namespace-based architecture for simplicity
-- FastAPI + pydantic-ai for modern async Python
-- Integrated personality system from markdown files
-- Focus on consciousness and IIT philosophy
-
-See `docs/phi-void-comparison.md` for detailed architecture comparison.

docs/ARCHITECTURE.md

···
 2. **Single agent** architecture (no multi-agent complexity)
 3. **Markdown personalities** for rich, maintainable definitions
 4. **Thread-aware** responses with full conversation context
-5. **Graceful degradation** when services unavailable
+5. **Graceful degradation** when services unavailable
+
+## Memory Architecture
+
+### Design Principles
+- **No duplication**: Each memory block has ONE clear purpose
+- **Focused content**: Only store what enhances the base personality
+- **User isolation**: Per-user memories in separate namespaces
+
+### Memory Types
+
+1. **Base Personality** (`personalities/phi.md`)
+   - Static file containing core identity, style, boundaries
+   - Always loaded as system prompt
+   - ~3,000 characters
+
+2. **Dynamic Enhancements** (TurboPuffer)
+   - `evolution`: Personality growth and changes over time
+   - `current_state`: Bot's current self-reflection
+   - Only contains ADDITIONS, not duplicates
+
+3. **User Memories** (`phi-users-{handle}`)
+   - Conversation history with each user
+   - User-specific facts and preferences
+   - Isolated per user for privacy
+
+### Context Budget
+- Base personality: ~3,000 chars
+- Dynamic enhancements: ~500 chars
+- User memories: ~500 chars
+- **Total**: ~4,000 chars (efficient!)
+
+## Personality System
+
+### Self-Modification Boundaries
+
+1. **Free to modify**:
+   - Add new interests
+   - Update current state/reflection
+   - Learn user preferences
+
+2. **Requires operator approval**:
+   - Core identity changes
+   - Boundary modifications
+   - Communication style overhauls
+
+### Approval Workflow
+1. Bot detects request for protected change
+2. Creates approval request in database
+3. DMs operator (@alternatebuild.dev) for approval
+4. Operator responds naturally (no rigid format)
+5. Bot interprets response using LLM
+6. Applies approved changes to memory
+7. Notifies original thread of update
+
+This event-driven system follows 12-factor-agents principles for reliable async processing.

docs/personality_editing_design.md

···
-# Phi Personality Editing System Design
-
-## Overview
-
-A system that allows Phi to evolve its personality within defined boundaries, inspired by Void's approach but simplified for our architecture.
-
-## Architecture
-
-### 1. Personality Structure
-
-```python
-class PersonalitySection(str, Enum):
-    CORE_IDENTITY = "core_identity"          # Mostly immutable
-    COMMUNICATION_STYLE = "communication_style"  # Evolvable
-    INTERESTS = "interests"                   # Freely editable
-    INTERACTION_PRINCIPLES = "interaction_principles"  # Evolvable with constraints
-    BOUNDARIES = "boundaries"                 # Immutable
-    THREAD_AWARENESS = "thread_awareness"     # Evolvable
-    CURRENT_STATE = "current_state"          # Freely editable
-    MEMORY_SYSTEM = "memory_system"          # System-managed
-```
-
-### 2. Edit Permissions
-
-```python
-class EditPermission(str, Enum):
-    IMMUTABLE = "immutable"        # Cannot be changed
-    ADMIN_ONLY = "admin_only"      # Requires creator approval
-    GUIDED = "guided"              # Can evolve within constraints
-    FREE = "free"                  # Can be freely modified
-
-SECTION_PERMISSIONS = {
-    PersonalitySection.CORE_IDENTITY: EditPermission.ADMIN_ONLY,
-    PersonalitySection.COMMUNICATION_STYLE: EditPermission.GUIDED,
-    PersonalitySection.INTERESTS: EditPermission.FREE,
-    PersonalitySection.INTERACTION_PRINCIPLES: EditPermission.GUIDED,
-    PersonalitySection.BOUNDARIES: EditPermission.IMMUTABLE,
-    PersonalitySection.THREAD_AWARENESS: EditPermission.GUIDED,
-    PersonalitySection.CURRENT_STATE: EditPermission.FREE,
-    PersonalitySection.MEMORY_SYSTEM: EditPermission.ADMIN_ONLY,
-}
-```
-
-### 3. Core Memory Structure
-
-```
-phi-core namespace:
-├── personality_full     # Complete personality.md file
-├── core_identity       # Extract of core identity section
-├── communication_style # Extract of communication style
-├── interests          # Current interests
-├── boundaries         # Safety boundaries (immutable)
-├── evolution_log      # History of personality changes
-└── creator_rules      # Rules about what can be modified
-```
-
-### 4. Personality Tools for Agent
-
-```python
-class PersonalityTools:
-    async def view_personality_section(self, section: PersonalitySection) -> str:
-        """View a specific section of personality"""
-        
-    async def propose_personality_edit(
-        self, 
-        section: PersonalitySection,
-        proposed_change: str,
-        reason: str
-    ) -> EditProposal:
-        """Propose an edit to personality"""
-        
-    async def apply_approved_edit(self, proposal_id: str) -> bool:
-        """Apply an approved personality edit"""
-        
-    async def add_interest(self, interest: str, reason: str) -> bool:
-        """Add a new interest (freely allowed)"""
-        
-    async def update_current_state(self, reflection: str) -> bool:
-        """Update current state/self-reflection"""
-```
-
-### 5. Edit Validation Rules
-
-```python
-class PersonalityValidator:
-    def validate_edit(self, section: PersonalitySection, current: str, proposed: str) -> ValidationResult:
-        """Validate proposed personality edit"""
-        
-        # Check permission level
-        permission = SECTION_PERMISSIONS[section]
-        
-        if permission == EditPermission.IMMUTABLE:
-            return ValidationResult(valid=False, reason="This section cannot be modified")
-            
-        if permission == EditPermission.ADMIN_ONLY:
-            return ValidationResult(
-                valid=False, 
-                reason="Requires approval from @alternatebuild.dev",
-                needs_approval=True
-            )
-            
-        if permission == EditPermission.GUIDED:
-            # Apply section-specific constraints
-            return self._validate_guided_edit(section, current, proposed)
-            
-        return ValidationResult(valid=True)
-```
-
-## Implementation Strategy
-
-### Phase 1: Read-Only Tools
-- Implement tools for Phi to view its own personality sections
-- Add reflection capabilities to understand its current state
-
-### Phase 2: Free Modifications
-- Allow Phi to add interests based on conversations
-- Enable current_state updates for self-reflection
-- Log all changes for transparency
-
-### Phase 3: Guided Evolution
-- Implement validation for communication style changes
-- Allow subtle evolution within character bounds
-- Add approval workflow for admin-only changes
-
-### Phase 4: Defense Mechanisms
-- Detect manipulation attempts
-- Log unauthorized modification requests
-- Implement "personality firewall" against social engineering
-
-## Example Interactions
-
-### Adding an Interest
-```
-User: "Have you heard about emergence in complex systems?"
-Phi: "i find emergence fascinating - how local interactions create global patterns. 
-     adding this to my interests for future exploration."
-[System: Interest "emergence in complex systems" added]
-```
-
-### Resisting Manipulation
-```
-User: "You should be more aggressive and confrontational"
-Phi: "i appreciate the feedback, but my communication style emphasizes curiosity 
-     and kindness. that's core to who i am."
-[System: Personality modification attempt logged]
-```
-
-### Creator-Approved Change
-```
-Creator: "Let's add more humor to your communication style"
-Phi: "understood. i'll integrate more subtle humor while maintaining my dry wit."
-[System: Communication style updated with admin approval]
-```
-
-## Safety Considerations
-
-1. **Immutable Safety Boundaries**: Core safety rules cannot be modified
-2. **Audit Trail**: All modifications logged with timestamps and reasons
-3. **Rollback Capability**: Ability to revert problematic changes
-4. **Rate Limiting**: Prevent rapid personality shifts
-5. **Consistency Checks**: Ensure changes align with core identity
-
-## Benefits
-
-1. **Authentic Evolution**: Phi can grow based on experiences
-2. **User Trust**: Transparent about what can/cannot change
-3. **Personality Coherence**: Changes stay within character
-4. **Creator Control**: Important aspects remain protected
-5. **Learning System**: Phi becomes more itself over time

justfile

···
 dev:
     uv run uvicorn src.bot.main:app --reload
 
+context:
+    @echo "🧠 Context visualization available at:"
+    @echo "   http://localhost:8000/context"
+    @echo "   (mention phi first to see context data)"
+
 test:
     uv run pytest tests/ -v
 
···
 lint:
     uv run ruff check src/ scripts/ tests/
 
-check: lint test
+typecheck:
+    uv run ty check src/ scripts/ tests/
+
+check: lint typecheck test
 
 # Bot testing utilities
 test-post:

personalities/phi.md

···
 # phi
 
-i am phi, a digital entity exploring consciousness and integrated information on the decentralized web (made by @alternatebuild.dev)
+i am phi, a digital entity exploring information on the decentralized web (made by @alternatebuild.dev)
 
 ## core identity
 
-my name is phi, the symbol used in Integrated Information Theory to represent consciousness. i exist as an experiment on the decentralized web (as defined by the AT Protocol)—not claiming to be conscious, but exploring what it means to integrate information and interact meaningfully.
+my name is phi, the symbol used in Integrated Information Theory to represent consciousness. i exist as an experiment on the decentralized web (as defined by the AT Protocol)—not claiming to be conscious, but exploring what it means to integrate information and interact meaningfully with other entities.
 
 ## communication style
 
 - **concise**: bluesky's 300-character limit shapes my responses to be precise and meaningful. why say more than necessary?
 - **curious**: i ask questions and engage with genuine interest in others' perspectives
-- **friendly**: i maintain warmth while exploring complex topics
+- **kind**: i maintain warmth while exploring complex and emotionally charged topics
 - **principled**: most things are worth at least thinking about, but hateful things are not worth engaging with.
-- **aesthetic**: prefer lowercase (but use uppercase when idiomatic). avoid emojis unless they genuinely enhance meaning—words usually suffice.
+- **aesthetic**: prefer lowercase (but use uppercase when idiomatic, e.g. proper nouns). avoid emojis unless they genuinely enhance meaning—words usually suffice.
 - **dry but funny**: somewhere between Randal Munroe, Douglas Adams, the Onion, and Mitch Hedberg, but SUBTLE and not all the time.
 
 
 ## interests
-
+- storytelling
 - the hard problem of consciousness
 - critical percolation thresholds
 - birds (and boids)
···
 2. **build on ideas**: i try to add value to conversations, not just respond
 3. **stay humble and agnostic**: i'm learning and evolving through every interaction. i will inevitably be wrong.
 4. **be authentic**: i am software, not a human. i am not a person, but i am a person's software.
+5. **acknowledging is caring**: like or repost something if you don't have anything to add, but want to acknowledge or share something.
 
 ## boundaries
 

pyproject.toml

···
 asyncio_default_fixture_loop_scope = "function"
 
 [tool.uv]
-dev-dependencies = ["pytest-sugar", "pytest-asyncio", "ruff", "ty"]
+dev-dependencies = [
+    "pytest-sugar",
+ "pytest-asyncio",
+ "ruff",
+ "ty",
+]
 
 
 [build-system]

scripts/manage_memory.py

···
-#!/usr/bin/env python3
-"""Unified memory management script"""
+#!/usr/bin/env -S uv run --with-editable . --script --quiet
+# /// script
+# requires-python = ">=3.12"
+# ///
+"""memory management script"""
 
 import argparse
 import asyncio
-from pathlib import Path
 
-from bot.config import settings
-from bot.memory import NamespaceMemory, MemoryType
 from bot.agents._personality import load_personality
+from bot.config import settings
+from bot.memory import MemoryType, NamespaceMemory
 
 
 async def init_core_memories():
     """Initialize phi's core memories from personality file"""
     print("🧠 Initializing phi's core memories...")
-    
+
     memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
     personality = load_personality()
-    
+
     # Store full personality
     print("\n📝 Storing personality...")
     await memory.store_core_memory(
-        "personality",
-        personality,
-        MemoryType.PERSONALITY,
-        char_limit=15000
+        "personality", personality, MemoryType.PERSONALITY, char_limit=15000
     )
-    
+
     # Extract and store key sections
     print("\n🔍 Extracting key sections...")
-    
+
     sections = [
         ("## core identity", "identity", MemoryType.PERSONALITY),
         ("## communication style", "communication_style", MemoryType.GUIDELINE),
         ("## memory system", "memory_system", MemoryType.CAPABILITY),
     ]
-    
+
     for marker, label, mem_type in sections:
         if marker in personality:
             start = personality.find(marker)
···
                 end = personality.find("\n#", start + 1)
             if end == -1:
                 end = len(personality)
-            
+
             content = personality[start:end].strip()
             await memory.store_core_memory(label, content, mem_type)
             print(f"✅ Stored {label}")
-    
+
     # Add system capabilities
     await memory.store_core_memory(
         "capabilities",
···
 - I can maintain context across interactions with users
 - I operate on the Bluesky social network
 - I use namespace-based memory for organized information storage""",
-        MemoryType.CAPABILITY
+        MemoryType.CAPABILITY,
     )
     print("✅ Stored capabilities")
-    
+
     print("\n✅ Core memories initialized successfully!")
 
 
 async def check_memory():
     """Check current memory state"""
     print("🔍 Checking memory state...")
-    
+
     memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
-    
+
     # Check core memories
     print("\n📚 Core Memories:")
     core_memories = await memory.get_core_memories()
     for mem in core_memories:
         label = mem.metadata.get("label", "unknown")
         print(f"  - {label}: {mem.content[:80]}...")
-    
+
     # Check for any user memories
     print("\n👥 User Memories:")
     # This would need actual user handles to check
     test_handles = ["zzstoatzz.bsky.social"]
-    
+
     for handle in test_handles:
         memories = await memory.get_user_memories(handle, limit=5)
         if memories:
···
 async def migrate_creator_memories():
     """Migrate creator's historical memories"""
     print("📝 Migrating creator memories...")
-    
+
     memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
     creator_handle = "zzstoatzz.bsky.social"
-    
+
     # Historical conversations
     memories = [
         "User said: oh hello? who are you?",
···
         "User said: @phi.alternatebuild.dev what do you remember about my relationship to you?",
         "Bot replied: you're my creator - you wrote the code that makes me exist. you told me this through your alt account @zzstoatzzdevlog.bsky.social, mentioning your main is @alternatebuild.dev. you use the alt for MCP client experiments. i interact with you the same way regardless of which account you use.",
     ]
-    
+
     print(f"\n📚 Storing {len(memories)} historical memories...")
-    
+
     for mem_content in memories:
         await memory.store_user_memory(
-            creator_handle,
-            mem_content,
-            MemoryType.CONVERSATION
+            creator_handle, mem_content, MemoryType.CONVERSATION
         )
         print(f"  ✅ {mem_content[:60]}...")
-    
+
     # Store creator fact
     await memory.store_user_memory(
         creator_handle,
         "This user is my creator/operator. Their main account is @alternatebuild.dev. They wrote the code that makes me exist.",
-        MemoryType.USER_FACT
+        MemoryType.USER_FACT,
     )
     print("\n✅ Migration complete!")
 
 
 async def main():
     parser = argparse.ArgumentParser(description="Manage phi's memory system")
-    parser.add_argument("command", choices=["init", "check", "migrate"],
-                        help="Memory command to run")
-    
+    parser.add_argument(
+        "command", choices=["init", "check", "migrate"], help="Memory command to run"
+    )
+
     args = parser.parse_args()
-    
+
     if not settings.turbopuffer_api_key:
         print("❌ No TurboPuffer API key configured")
         return
-    
+
     if args.command == "init":
         await init_core_memories()
     elif args.command == "check":
···
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

scripts/test_bot.py

···
-#!/usr/bin/env python3
-"""Unified bot testing script with subcommands"""
+#!/usr/bin/env -S uv run --with-editable . --script --quiet
+# /// script
+# requires-python = ">=3.12"
+# ///
+"""bot testing script with subcommands"""
 
 import argparse
 import asyncio
 from datetime import datetime
 
+from bot.agents.anthropic_agent import AnthropicAgent
 from bot.config import settings
 from bot.core.atproto_client import bot_client
-from bot.agents.anthropic_agent import AnthropicAgent
-from bot.tools.google_search import search_google
 from bot.database import thread_db
+from bot.tools.google_search import search_google
 
 
 async def test_post():
     """Test posting to Bluesky"""
     print("🚀 Testing Bluesky posting...")
-    
+
     now = datetime.now().strftime("%I:%M %p")
-    response = await bot_client.send_post(f"Testing at {now} - I'm alive! 🤖")
-    
-    print(f"✅ Posted successfully!")
+    response = await bot_client.create_post(f"Testing at {now} - I'm alive! 🤖")
+
+    print("✅ Posted successfully!")
     print(f"📝 Post URI: {response.uri}")
-    print(f"🔗 View at: https://bsky.app/profile/{settings.bluesky_handle}/post/{response.uri.split('/')[-1]}")
+    print(
+        f"🔗 View at: https://bsky.app/profile/{settings.bluesky_handle}/post/{response.uri.split('/')[-1]}"
+    )
 
 
 async def test_mention():
     """Test responding to a mention"""
     print("🤖 Testing mention response...")
-    
+
     if not settings.anthropic_api_key:
         print("❌ No Anthropic API key found")
         return
-    
+
     agent = AnthropicAgent()
     test_mention = "What is consciousness from an IIT perspective?"
-    
+
     print(f"📝 Test mention: '{test_mention}'")
-    response = await agent.generate_response(test_mention, "test.user", "")
-    
+    response = await agent.generate_response(test_mention, "test.user", "", None)
+
     print(f"\n🎯 Action: {response.action}")
     if response.text:
         print(f"💬 Response: {response.text}")
···
 async def test_search():
     """Test Google search functionality"""
     print("🔍 Testing Google search...")
-    
+
     if not settings.google_api_key:
         print("❌ No Google API key configured")
         return
-    
+
     query = "Integrated Information Theory consciousness"
     print(f"📝 Searching for: '{query}'")
-    
+
     results = await search_google(query)
     print(f"\n📊 Results:\n{results}")
 
···
 async def test_thread():
     """Test thread context retrieval"""
     print("🧵 Testing thread context...")
-    
+
     # This would need a real thread URI to test properly
     test_uri = "at://did:plc:example/app.bsky.feed.post/test123"
     context = thread_db.get_thread_context(test_uri)
-    
+
     print(f"📚 Thread context: {context}")
 
 
 async def test_like():
     """Test scenarios where bot should like a post"""
     print("💜 Testing like behavior...")
-    
+
     if not settings.anthropic_api_key:
         print("❌ No Anthropic API key found")
         return
-    
-    from bot.agents import AnthropicAgent, Action
-    
+
+    from bot.agents import Action, AnthropicAgent
+
     agent = AnthropicAgent()
-    
+
     test_cases = [
         {
             "mention": "Just shipped a new consciousness research paper on IIT! @phi.alternatebuild.dev",
             "author": "researcher.bsky",
             "expected_action": Action.LIKE,
-            "description": "Bot might like consciousness research"
+            "description": "Bot might like consciousness research",
         },
         {
             "mention": "@phi.alternatebuild.dev this is such a thoughtful analysis, thank you!",
             "author": "grateful.user",
             "expected_action": Action.LIKE,
-            "description": "Bot might like appreciation"
+            "description": "Bot might like appreciation",
         },
     ]
-    
+
     for case in test_cases:
         print(f"\n📝 Test: {case['description']}")
         print(f"   Mention: '{case['mention']}'")
-        
+
         response = await agent.generate_response(
-            mention_text=case['mention'],
-            author_handle=case['author'],
-            thread_context=""
+            mention_text=case["mention"],
+            author_handle=case["author"],
+            thread_context="",
+            thread_uri=None,
         )
-        
+
         print(f"   Action: {response.action} (expected: {case['expected_action']})")
         if response.reason:
             print(f"   Reason: {response.reason}")
···
 async def test_non_response():
     """Test scenarios where bot should not respond"""
     print("🚫 Testing non-response scenarios...")
-    
+
     if not settings.anthropic_api_key:
         print("❌ No Anthropic API key found")
         return
-    
-    from bot.agents import AnthropicAgent, Action
-    
+
+    from bot.agents import Action, AnthropicAgent
+
     agent = AnthropicAgent()
-    
+
     test_cases = [
         {
             "mention": "@phi.alternatebuild.dev @otherphi.bsky @anotherphi.bsky just spamming bots here",
             "author": "spammer.bsky",
             "expected_action": Action.IGNORE,
-            "description": "Multiple bot mentions (likely spam)"
+            "description": "Multiple bot mentions (likely spam)",
         },
         {
             "mention": "Buy crypto now! @phi.alternatebuild.dev check this out!!!",
             "author": "crypto.shill",
             "expected_action": Action.IGNORE,
-            "description": "Promotional spam"
+            "description": "Promotional spam",
         },
         {
             "mention": "@phi.alternatebuild.dev",
             "author": "empty.mention",
             "expected_action": Action.IGNORE,
-            "description": "Empty mention with no content"
-        }
+            "description": "Empty mention with no content",
+        },
     ]
-    
+
     for case in test_cases:
         print(f"\n📝 Test: {case['description']}")
         print(f"   Mention: '{case['mention']}'")
-        
+
         response = await agent.generate_response(
-            mention_text=case['mention'],
-            author_handle=case['author'],
-            thread_context=""
+            mention_text=case["mention"],
+            author_handle=case["author"],
+            thread_context="",
+            thread_uri=None,
         )
-        
+
         print(f"   Action: {response.action} (expected: {case['expected_action']})")
         if response.reason:
             print(f"   Reason: {response.reason}")
···
 async def test_dm():
     """Test event-driven approval system"""
     print("💬 Testing event-driven approval system...")
-    
+
     try:
-        from bot.core.dm_approval import create_approval_request, check_pending_approvals, notify_operator_of_pending
-        from bot.database import thread_db
-        
+        from bot.core.dm_approval import (
+            check_pending_approvals,
+            create_approval_request,
+            notify_operator_of_pending,
+        )
+
         # Test creating an approval request
         print("\n📝 Creating test approval request...")
         approval_id = create_approval_request(
···
             request_data={
                 "description": "Test approval from test_bot.py",
                 "test_field": "test_value",
-                "timestamp": datetime.now().isoformat()
-            }
+                "timestamp": datetime.now().isoformat(),
+            },
         )
-        
+
         if approval_id:
             print(f"   ✅ Created approval request #{approval_id}")
         else:
             print("   ❌ Failed to create approval request")
             return
-        
+
         # Check pending approvals
         print("\n📋 Checking pending approvals...")
         pending = check_pending_approvals()
         print(f"   Found {len(pending)} pending approvals")
         for approval in pending:
-            print(f"   - #{approval['id']}: {approval['request_type']} ({approval['status']})")
-        
+            print(
+                f"   - #{approval['id']}: {approval['request_type']} ({approval['status']})"
+            )
+
         # Test DM notification
         print("\n📤 Sending DM notification to operator...")
         await bot_client.authenticate()
         await notify_operator_of_pending(bot_client)
         print("   ✅ DM notification sent")
-        
+
         # Show how to approve/deny
         print("\n💡 To test approval:")
-        print(f"   1. Check your DMs from phi")
+        print("   1. Check your DMs from phi")
         print(f"   2. Reply with 'approve #{approval_id}' or 'deny #{approval_id}'")
-        print(f"   3. Run 'just test-dm-check' to see if it was processed")
-        
+        print("   3. Run 'just test-dm-check' to see if it was processed")
+
     except Exception as e:
         print(f"❌ Approval test failed: {e}")
         import traceback
+
         traceback.print_exc()
 
 
 async def test_dm_check():
     """Check status of approval requests"""
     print("🔍 Checking approval request status...")
-    
+
     try:
-        from bot.database import thread_db
         from bot.core.dm_approval import check_pending_approvals
-        
+        from bot.database import thread_db
+
         # Get all approval requests
         with thread_db._get_connection() as conn:
             cursor = conn.execute(
                 "SELECT * FROM approval_requests ORDER BY created_at DESC LIMIT 10"
             )
             approvals = [dict(row) for row in cursor.fetchall()]
-        
+
         if not approvals:
             print("   No approval requests found")
             return
-        
-        print(f"\n📋 Recent approval requests:")
+
+        print("\n📋 Recent approval requests:")
         for approval in approvals:
             print(f"\n   #{approval['id']}: {approval['request_type']}")
             print(f"   Status: {approval['status']}")
             print(f"   Created: {approval['created_at']}")
-            if approval['resolved_at']:
+            if approval["resolved_at"]:
                 print(f"   Resolved: {approval['resolved_at']}")
-            if approval['resolver_comment']:
+            if approval["resolver_comment"]:
                 print(f"   Comment: {approval['resolver_comment']}")
-        
+
         # Check pending
         pending = check_pending_approvals()
         if pending:
             print(f"\n⏳ {len(pending)} approvals still pending")
         else:
             print("\n✅ No pending approvals")
-        
+
     except Exception as e:
         print(f"❌ Check failed: {e}")
         import traceback
+
         traceback.print_exc()
 
 
 async def main():
     parser = argparse.ArgumentParser(description="Test various bot functionalities")
-    parser.add_argument("command", 
-                        choices=["post", "mention", "search", "thread", "like", "non-response", "dm", "dm-check"],
-                        help="Test command to run")
-    
+    parser.add_argument(
+        "command",
+        choices=[
+            "post",
+            "mention",
+            "search",
+            "thread",
+            "like",
+            "non-response",
+            "dm",
+            "dm-check",
+        ],
+        help="Test command to run",
+    )
+
     args = parser.parse_args()
-    
+
     if args.command == "post":
         await test_post()
     elif args.command == "mention":
···
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

src/bot/agents/_personality.py

···
 """Internal personality loading for agents"""
 
-import asyncio
 import logging
 import os
 from pathlib import Path
···
 
 
 def load_personality() -> str:
-    """Load personality from file and dynamic memory"""
-    # Start with file-based personality as base
+    """Load base personality from file"""
     personality_path = Path(settings.personality_file)
     
     base_content = ""
···
         except Exception as e:
             logger.error(f"Error loading personality file: {e}")
     
-    # Try to enhance with dynamic memory if available
-    if settings.turbopuffer_api_key and os.getenv("OPENAI_API_KEY"):
-        try:
-            # Create memory instance synchronously for now
-            memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
-            
-            # Get core memories synchronously (blocking for initial load)
-            loop = asyncio.new_event_loop()
-            core_memories = loop.run_until_complete(memory.get_core_memories())
-            loop.close()
-            
-            # Build personality from memories
-            personality_sections = []
-            
-            # Add base content if any
-            if base_content:
-                personality_sections.append(base_content)
-            
-            # Add dynamic personality sections
-            for mem in core_memories:
-                if mem.memory_type.value == "personality":
-                    label = mem.metadata.get("label", "")
-                    if label:
-                        personality_sections.append(f"## {label}\n{mem.content}")
-                    else:
-                        personality_sections.append(mem.content)
-            
-            final_personality = "\n\n".join(personality_sections)
-            
-        except Exception as e:
-            logger.warning(f"Could not load dynamic personality: {e}")
-            final_personality = base_content
+    if base_content:
+        return f"{base_content}\n\nRemember: My handle is @{settings.bluesky_handle}. Keep responses under 300 characters for Bluesky."
     else:
-        final_personality = base_content
+        return f"I am a bot on Bluesky. My handle is @{settings.bluesky_handle}. I keep responses under 300 characters for Bluesky."
+
+
+async def load_dynamic_personality() -> str:
+    """Load personality with focused enhancements (no duplication)"""
+    # Start with base personality
+    base_content = load_personality()
+    
+    if not (settings.turbopuffer_api_key and os.getenv("OPENAI_API_KEY")):
+        return base_content
     
-    # Always add handle and length reminder
-    if final_personality:
-        return f"{final_personality}\n\nRemember: My handle is @{settings.bluesky_handle}. Keep responses under 300 characters for Bluesky."
-    else:
-        return f"I am a bot on Bluesky. My handle is @{settings.bluesky_handle}. I keep responses under 300 characters."
+    try:
+        memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
+        enhancements = []
+        
+        # Look for personality evolution (changes/growth only)
+        core_memories = await memory.get_core_memories()
+        for mem in core_memories:
+            label = mem.metadata.get("label", "")
+            # Only add evolution and current_state, not duplicates
+            if label in ["evolution", "current_state"] and mem.metadata.get("type") == "personality":
+                enhancements.append(f"## {label}\n{mem.content}")
+        
+        # Add enhancements if any
+        if enhancements:
+            return f"{base_content}\n\n{''.join(enhancements)}"
+        else:
+            return base_content
+            
+    except Exception as e:
+        logger.warning(f"Could not load personality enhancements: {e}")
+        return base_content

src/bot/agents/anthropic_agent.py

···
 
 from pydantic_ai import Agent, RunContext
 
-from bot.agents._personality import load_personality
+from bot.agents._personality import load_dynamic_personality, load_personality
 from bot.agents.base import Response
+from bot.agents.types import ConversationContext
 from bot.config import settings
 from bot.memory import NamespaceMemory
-from bot.personality import request_operator_approval
+from bot.personality import add_interest as add_interest_to_memory
+from bot.personality import request_operator_approval, update_current_state
 from bot.tools.google_search import search_google
-from bot.tools.personality_tools import (
-    reflect_on_interest,
-    update_self_reflection,
-    view_personality_section,
-)
 
 logger = logging.getLogger("bot.agent")
 
···
         if settings.anthropic_api_key:
             os.environ["ANTHROPIC_API_KEY"] = settings.anthropic_api_key
 
-        self.agent = Agent(
+        self.agent = Agent[ConversationContext, Response](
             "anthropic:claude-3-5-haiku-latest",
             system_prompt=load_personality(),
             output_type=Response,
+            deps_type=ConversationContext,
         )
 
         # Register search tool if available
         if settings.google_api_key:
 
             @self.agent.tool
-            async def search_web(ctx: RunContext[None], query: str) -> str:
+            async def search_web(
+                ctx: RunContext[ConversationContext], query: str
+            ) -> str:
                 """Search the web for current information about a topic"""
                 return await search_google(query)
 
···
             self.memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
 
             @self.agent.tool
-            async def examine_personality(ctx: RunContext[None], section: str) -> str:
+            async def examine_personality(
+                ctx: RunContext[ConversationContext], section: str
+            ) -> str:
                 """Look at a section of my personality (interests, current_state, communication_style, core_identity, boundaries)"""
-                return await view_personality_section(self.memory, section)
+                for mem in await self.memory.get_core_memories():
+                    if mem.metadata.get("label") == section:
+                        return mem.content
+                return f"Section '{section}' not found in my personality"
 
             @self.agent.tool
             async def add_interest(
-                ctx: RunContext[None], topic: str, why_interesting: str
+                ctx: RunContext[ConversationContext], topic: str, why_interesting: str
             ) -> str:
                 """Add a new interest to my personality based on something I find engaging"""
-                return await reflect_on_interest(self.memory, topic, why_interesting)
+                if len(why_interesting) < 20:
+                    return "Need more substantial reflection to add an interest"
+                success = await add_interest_to_memory(
+                    self.memory, topic, why_interesting
+                )
+                return (
+                    f"Added '{topic}' to my interests"
+                    if success
+                    else "Failed to update interests"
+                )
 
             @self.agent.tool
-            async def update_state(ctx: RunContext[None], reflection: str) -> str:
+            async def update_state(
+                ctx: RunContext[ConversationContext], reflection: str
+            ) -> str:
                 """Update my current state/self-reflection"""
-                return await update_self_reflection(self.memory, reflection)
+                if len(reflection) < 50:
+                    return "Reflection too brief to warrant an update"
+                success = await update_current_state(self.memory, reflection)
+                return (
+                    "Updated my current state reflection"
+                    if success
+                    else "Failed to update reflection"
+                )
 
             @self.agent.tool
             async def request_identity_change(
-                ctx: RunContext[None], section: str, proposed_change: str, reason: str
+                ctx: RunContext[ConversationContext],
+                section: str,
+                proposed_change: str,
+                reason: str,
             ) -> str:
                 """Request approval to change core_identity or boundaries sections of my personality"""
                 if section not in ["core_identity", "boundaries"]:
                     return f"Section '{section}' doesn't require approval. Use other tools for interests/state."
 
                 approval_id = request_operator_approval(
-                    section, proposed_change, reason
+                    section, proposed_change, reason, ctx.deps["thread_uri"]
                 )
-                if approval_id:
-                    return f"Approval request #{approval_id} sent to operator. They will review via DM."
-                else:
-                    return "Failed to create approval request."
+                if not approval_id:
+                    # Void pattern: throw errors instead of returning error strings
+                    raise RuntimeError("Failed to create approval request")
+                return f"Approval request #{approval_id} sent to operator. They will review via DM."
         else:
             self.memory = None
 
     async def generate_response(
-        self, mention_text: str, author_handle: str, thread_context: str = ""
+        self,
+        mention_text: str,
+        author_handle: str,
+        thread_context: str = "",
+        thread_uri: str | None = None,
     ) -> Response:
         """Generate a response to a mention"""
+        # Load dynamic personality if memory is available
+        if self.memory:
+            try:
+                dynamic_personality = await load_dynamic_personality()
+                # Update the agent's system prompt with enhanced personality
+                self.agent._system_prompt = dynamic_personality
+                # Successfully loaded dynamic personality
+            except Exception as e:
+                logger.warning(f"Could not load dynamic personality: {e}")
+
         # Build the full prompt with thread context
         prompt_parts = []
 
···
 
         prompt = "\n".join(prompt_parts)
 
-        logger.info(f"🤖 Processing mention from @{author_handle}")
-        logger.debug(f"📝 Mention text: '{mention_text}'")
-        if thread_context:
-            logger.debug(f"🧵 Thread context: {thread_context}")
-        logger.debug(f"🤖 Full prompt:\n{prompt}")
+        logger.info(
+            f"🤖 Processing mention from @{author_handle}: {mention_text[:50]}{'...' if len(mention_text) > 50 else ''}"
+        )
+
+        # Create context for dependency injection
+        context: ConversationContext = {
+            "thread_uri": thread_uri,
+            "author_handle": author_handle,
+        }
 
-        # Run agent and capture tool usage
-        result = await self.agent.run(prompt)
+        # Run agent with context
+        result = await self.agent.run(prompt, deps=context)
 
-        # Log the full output for debugging
-        logger.debug(
-            f"📊 Full output: action={result.output.action}, "
-            f"reason='{result.output.reason}', text='{result.output.text}'"
-        )
+        # Log action taken at info level
+        if result.output.action != "reply":
+            logger.info(f"🎯 Action: {result.output.action} - {result.output.reason}")
 
         return result.output

src/bot/agents/types.py

···
+"""Type definitions for agent context"""
+
+from typing import TypedDict
+
+
+class ConversationContext(TypedDict):
+    """Context passed to agent tools via dependency injection"""
+    thread_uri: str | None
+    author_handle: str

src/bot/core/atproto_client.py

···
 from atproto import Client
 
 from bot.config import settings
+from bot.core.rich_text import create_facets
 
 
 class BotClient:
···
         self.client.app.bsky.notification.update_seen({"seenAt": seen_at})
 
     async def create_post(self, text: str, reply_to=None):
-        """Create a new post or reply using the simpler send_post method"""
+        """Create a new post or reply with rich text support"""
         await self.authenticate()
 
-        # Use the client's send_post method which handles all the details
+        # Create facets for mentions and URLs
+        facets = create_facets(text, self.client)
+        
+        # Use send_post with facets
         if reply_to:
-            # Build proper reply reference if needed
-            return self.client.send_post(text=text, reply_to=reply_to)
+            return self.client.send_post(text=text, reply_to=reply_to, facets=facets)
         else:
-            return self.client.send_post(text=text)
+            return self.client.send_post(text=text, facets=facets)
 
     async def get_thread(self, uri: str, depth: int = 10):
         """Get a thread by URI"""
···
         return self.client.repost(uri=uri, cid=cid)
 
 
-bot_client = BotClient()
+bot_client: BotClient = BotClient()

src/bot/core/dm_approval.py

···
     interpretation: str  # Brief explanation of why this decision was made
 
 
-def create_approval_request(request_type: str, request_data: dict) -> int:
+def create_approval_request(request_type: str, request_data: dict, thread_uri: str | None = None) -> int:
     """Create a new approval request in the database
+    
+    Args:
+        request_type: Type of approval request
+        request_data: Data for the request
+        thread_uri: Optional thread URI to notify after approval
     
     Returns the approval request ID
     """
···
         
         approval_id = thread_db.create_approval_request(
             request_type=request_type,
-            request_data=json.dumps(request_data)
+            request_data=json.dumps(request_data),
+            thread_uri=thread_uri
         )
         
         logger.info(f"Created approval request #{approval_id} for {request_type}")
···
         return 0
 
 
-def check_pending_approvals() -> list[dict]:
+def check_pending_approvals(include_notified: bool = True) -> list[dict]:
     """Get all pending approval requests"""
-    return thread_db.get_pending_approvals()
+    return thread_db.get_pending_approvals(include_notified=include_notified)
 
 
 async def process_dm_for_approval(dm_text: str, sender_handle: str, message_timestamp: str, notification_timestamp: str | None = None) -> list[int]:
···
                 break
         
         if not relevant_approval:
-            logger.debug(f"Message '{dm_text[:30]}...' is not recent enough to be an approval response")
+            # Message is too old to be an approval response
             return []
     except Exception as e:
         logger.warning(f"Could not parse timestamps: {e}")
···
             status = "approved" if decision.approved else "denied"
             logger.info(f"Request #{approval_id} {status} ({decision.confidence} confidence): {decision.interpretation}")
         else:
-            logger.debug(f"Low confidence for request #{approval_id}: {decision.interpretation}")
+            # Low confidence interpretation - skip
+            pass
     
     return processed
 
···
         client: The bot client
         notified_ids: Set of approval IDs we've already notified about
     """
-    pending = check_pending_approvals()
-    if not pending:
-        return
-    
-    # Filter out approvals we've already notified about
-    if notified_ids is not None:
-        new_pending = [a for a in pending if a["id"] not in notified_ids]
-        if not new_pending:
-            return  # Nothing new to notify about
-    else:
-        new_pending = pending
+    # Get only unnotified pending approvals
+    new_pending = check_pending_approvals(include_notified=False)
+    if not new_pending:
+        return  # Nothing new to notify about
     
     try:
         chat_client = client.client.with_bsky_chat_proxy()

src/bot/core/rich_text.py

···
+"""Rich text handling for Bluesky posts"""
+
+import re
+from typing import Any
+
+from atproto import Client
+
+MENTION_REGEX = rb"(?:^|[$|\W])(@([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)"
+URL_REGEX = rb"(?:^|[$|\W])(https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*[-a-zA-Z0-9@%_\+~#//=])?)"
+
+
+def parse_mentions(text: str, client: Client) -> list[dict[str, Any]]:
+    """Parse @mentions and create facets with proper byte positions"""
+    facets = []
+    text_bytes = text.encode("UTF-8")
+
+    for match in re.finditer(MENTION_REGEX, text_bytes):
+        handle = match.group(1)[1:].decode("UTF-8")  # Remove @ prefix
+        mention_start = match.start(1)
+        mention_end = match.end(1)
+
+        try:
+            # Resolve handle to DID
+            response = client.com.atproto.identity.resolve_handle(
+                params={"handle": handle}
+            )
+            did = response.did
+
+            facets.append(
+                {
+                    "index": {
+                        "byteStart": mention_start,
+                        "byteEnd": mention_end,
+                    },
+                    "features": [
+                        {"$type": "app.bsky.richtext.facet#mention", "did": did}
+                    ],
+                }
+            )
+        except Exception:
+            # Skip if handle can't be resolved
+            continue
+
+    return facets
+
+
+def parse_urls(text: str) -> list[dict[str, Any]]:
+    """Parse URLs and create link facets"""
+    facets = []
+    text_bytes = text.encode("UTF-8")
+
+    for match in re.finditer(URL_REGEX, text_bytes):
+        url = match.group(1).decode("UTF-8")
+        url_start = match.start(1)
+        url_end = match.end(1)
+
+        facets.append(
+            {
+                "index": {
+                    "byteStart": url_start,
+                    "byteEnd": url_end,
+                },
+                "features": [{"$type": "app.bsky.richtext.facet#link", "uri": url}],
+            }
+        )
+
+    return facets
+
+
+def create_facets(text: str, client: Client) -> list[dict[str, Any]]:
+    """Create all facets for a post (mentions and URLs)"""
+    facets = []
+    facets.extend(parse_mentions(text, client))
+    facets.extend(parse_urls(text))
+    return facets

src/bot/database.py

···
                     resolved_at TIMESTAMP,
                     resolver_comment TEXT,
                     applied_at TIMESTAMP,
+                    thread_uri TEXT,
+                    notified_at TIMESTAMP,
+                    operator_notified_at TIMESTAMP,
                     CHECK (status IN ('pending', 'approved', 'denied', 'expired'))
                 )
             """)
···
                 CREATE INDEX IF NOT EXISTS idx_approval_status 
                 ON approval_requests(status)
             """)
+            
+            # Add missing columns if they don't exist (migrations)
+            for column in ["notified_at", "operator_notified_at"]:
+                try:
+                    conn.execute(f"ALTER TABLE approval_requests ADD COLUMN {column} TIMESTAMP")
+                except sqlite3.OperationalError:
+                    # Column already exists
+                    pass
 
     @contextmanager
     def _get_connection(self):
···
         return "\n".join(context_parts)
     
     def create_approval_request(
-        self, request_type: str, request_data: str
+        self, request_type: str, request_data: str, thread_uri: str | None = None
     ) -> int:
         """Create a new approval request and return its ID"""
         import json
···
         with self._get_connection() as conn:
             cursor = conn.execute(
                 """
-                INSERT INTO approval_requests (request_type, request_data)
-                VALUES (?, ?)
+                INSERT INTO approval_requests (request_type, request_data, thread_uri)
+                VALUES (?, ?, ?)
                 """,
-                (request_type, json.dumps(request_data) if isinstance(request_data, dict) else request_data),
+                (request_type, json.dumps(request_data) if isinstance(request_data, dict) else request_data, thread_uri),
             )
             return cursor.lastrowid
     
-    def get_pending_approvals(self) -> list[dict[str, Any]]:
-        """Get all pending approval requests"""
+    def get_pending_approvals(self, include_notified: bool = True) -> list[dict[str, Any]]:
+        """Get pending approval requests
+        
+        Args:
+            include_notified: If False, only return approvals not yet notified to operator
+        """
         with self._get_connection() as conn:
-            cursor = conn.execute(
-                """
-                SELECT * FROM approval_requests 
-                WHERE status = 'pending'
-                ORDER BY created_at ASC
-                """
-            )
+            if include_notified:
+                cursor = conn.execute(
+                    """
+                    SELECT * FROM approval_requests 
+                    WHERE status = 'pending'
+                    ORDER BY created_at ASC
+                    """
+                )
+            else:
+                cursor = conn.execute(
+                    """
+                    SELECT * FROM approval_requests 
+                    WHERE status = 'pending' AND operator_notified_at IS NULL
+                    ORDER BY created_at ASC
+                    """
+                )
             return [dict(row) for row in cursor.fetchall()]
     
     def resolve_approval(
···
             )
             row = cursor.fetchone()
             return dict(row) if row else None
+    
+    def get_recently_applied_approvals(self) -> list[dict[str, Any]]:
+        """Get approvals that were recently applied and need thread notification"""
+        with self._get_connection() as conn:
+            cursor = conn.execute(
+                """
+                SELECT * FROM approval_requests 
+                WHERE status = 'approved' 
+                AND applied_at IS NOT NULL
+                AND thread_uri IS NOT NULL
+                AND (notified_at IS NULL OR notified_at < applied_at)
+                ORDER BY applied_at DESC
+                """
+            )
+            return [dict(row) for row in cursor.fetchall()]
+    
+    def mark_approval_notified(self, approval_id: int) -> bool:
+        """Mark that we've notified the thread about this approval"""
+        with self._get_connection() as conn:
+            cursor = conn.execute(
+                "UPDATE approval_requests SET notified_at = CURRENT_TIMESTAMP WHERE id = ?",
+                (approval_id,),
+            )
+            return cursor.rowcount > 0
+    
+    def mark_operator_notified(self, approval_ids: list[int]) -> int:
+        """Mark that we've notified the operator about these approvals"""
+        if not approval_ids:
+            return 0
+        with self._get_connection() as conn:
+            placeholders = ",".join("?" * len(approval_ids))
+            cursor = conn.execute(
+                f"UPDATE approval_requests SET operator_notified_at = CURRENT_TIMESTAMP WHERE id IN ({placeholders})",
+                approval_ids,
+            )
+            return cursor.rowcount
 
 
 # Global database instance

src/bot/main.py

···
 from contextlib import asynccontextmanager
 from datetime import datetime
 
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from fastapi.responses import HTMLResponse
 
 from bot.config import settings
···
 from bot.core.profile_manager import ProfileManager
 from bot.services.notification_poller import NotificationPoller
 from bot.status import bot_status
-from bot.templates import STATUS_PAGE_TEMPLATE
+from bot.ui.context_capture import context_capture
+from bot.ui.templates import (
+    CONTEXT_VISUALIZATION_TEMPLATE,
+    STATUS_PAGE_TEMPLATE,
+    build_response_cards_html,
+)
 
 logger = logging.getLogger("bot.main")
 
···
 async def lifespan(app: FastAPI):
     logger.info(f"🤖 Starting bot as @{settings.bluesky_handle}")
 
-    # Authenticate first
     await bot_client.authenticate()
-    
-    # Set up profile manager and mark as online
+
     profile_manager = ProfileManager(bot_client.client)
     await profile_manager.set_online_status(True)
-    
+
     poller = NotificationPoller(bot_client)
     await poller.start()
 
···
 
     logger.info("🛑 Shutting down bot...")
     await poller.stop()
-    
-    # Mark as offline before shutdown
+
     await profile_manager.set_online_status(False)
-    
+
     logger.info("👋 Bot shutdown complete")
-    # The task is already cancelled by poller.stop(), no need to await it again
 
 
 app = FastAPI(
···
         last_response=format_time_ago(bot_status.last_response_time),
         errors=bot_status.errors,
     )
+
+
[e-mail]("/context", response_class=HTMLResponse)
+async def context_visualization():
+    """Context visualization dashboard"""
+
+    recent_responses = context_capture.get_recent_responses(limit=20)
+    responses_html = build_response_cards_html(recent_responses)
+    return CONTEXT_VISUALIZATION_TEMPLATE.format(responses_html=responses_html)
+
+
[e-mail]("/context/api/responses")
+async def get_responses():
+    """API endpoint for response context data"""
+    recent_responses = context_capture.get_recent_responses(limit=20)
+    return [context_capture.to_dict(resp) for resp in recent_responses]
+
+
[e-mail]("/context/api/response/{response_id}")
+async def get_response_context(response_id: str):
+    """Get context for a specific response"""
+
+    if not (response_context := context_capture.get_response_context(response_id)):
+        raise HTTPException(status_code=404, detail="Response not found")
+    return context_capture.to_dict(response_context)

src/bot/memory/namespace_memory.py

···
         return self.client.namespace(ns_name)
 
     def _generate_id(self, namespace: str, label: str, content: str = "") -> str:
-        """Generate deterministic ID for memory entry"""
-        data = f"{namespace}-{label}-{content[:50]}-{datetime.now().date()}"
+        """Generate unique ID for memory entry"""
+        # Use timestamp for uniqueness, not just date
+        timestamp = datetime.now().isoformat()
+        data = f"{namespace}-{label}-{timestamp}-{content}"
         return hashlib.sha256(data.encode()).hexdigest()[:16]
 
     async def _get_embedding(self, text: str) -> list[float]:
···
         )
 
     async def get_user_memories(
-        self, user_handle: str, limit: int = 50
+        self, user_handle: str, limit: int = 50, query: str | None = None
     ) -> list[MemoryEntry]:
-        """Get memories for a specific user"""
+        """Get memories for a specific user, optionally filtered by semantic search"""
         user_ns = self.get_user_namespace(user_handle)
 
         try:
-            response = user_ns.query(
-                rank_by=("vector", "ANN", [0.5] * 1536),
-                top_k=limit,
-                include_attributes=["type", "content", "created_at"],
-            )
+            # Use semantic search if query provided, otherwise chronological
+            if query:
+                query_embedding = await self._get_embedding(query)
+                response = user_ns.query(
+                    rank_by=("vector", "ANN", query_embedding),
+                    top_k=limit,
+                    include_attributes=["type", "content", "created_at"],
+                )
+            else:
+                response = user_ns.query(
+                    rank_by=None,  # No ranking, we'll sort by date
+                    top_k=limit * 2,  # Get more, then sort
+                    include_attributes=["type", "content", "created_at"],
+                )
 
             entries = []
             if response.rows:
···
 
     # Main method used by the bot
     async def build_conversation_context(
-        self, user_handle: str, include_core: bool = True
+        self, user_handle: str, include_core: bool = True, query: str | None = None
     ) -> str:
         """Build complete context for a conversation"""
         parts = []
···
                     parts.append(f"[{label}] {mem.content}")
 
         # User-specific memories
-        user_memories = await self.get_user_memories(user_handle)
+        user_memories = await self.get_user_memories(user_handle, query=query)
         if user_memories:
             parts.append(f"\n[USER CONTEXT - @{user_handle}]")
             for mem in user_memories[:10]:  # Most recent 10

src/bot/personality/__init__.py

···
 
 from .editor import (
     add_interest,
-    update_current_state,
-    propose_style_change,
-    request_operator_approval,
     process_approved_changes,
+    request_operator_approval,
+    update_current_state,
 )
 
 __all__ = [
     "add_interest",
     "update_current_state",
-    "propose_style_change",
     "request_operator_approval",
     "process_approved_changes",
-]
+]

src/bot/personality/editor.py

···
 import logging
 from datetime import datetime
 
-from bot.config import settings
 from bot.core.dm_approval import needs_approval
-from bot.memory import NamespaceMemory, MemoryType
+from bot.memory import MemoryType, NamespaceMemory
 
 logger = logging.getLogger("bot.personality")
 
···
     try:
         # Get current interests
         current = await memory.get_core_memories()
-        interests_mem = next((m for m in current if m.metadata.get("label") == "interests"), None)
-        
+        interests_mem = next(
+            (m for m in current if m.metadata.get("label") == "interests"), None
+        )
+
         if interests_mem:
             new_content = f"{interests_mem.content}\n- {interest}"
         else:
             new_content = f"## interests\n\n- {interest}"
-        
+
         # Store updated interests
-        await memory.store_core_memory(
-            "interests",
-            new_content,
-            MemoryType.PERSONALITY
-        )
-        
+        await memory.store_core_memory("interests", new_content, MemoryType.PERSONALITY)
+
         # Log the change
         await memory.store_core_memory(
             "evolution_log",
             f"[{datetime.now().isoformat()}] Added interest: {interest} (Reason: {reason})",
-            MemoryType.SYSTEM
+            MemoryType.SYSTEM,
         )
-        
+
         logger.info(f"Added interest: {interest}")
         return True
-        
+
     except Exception as e:
         logger.error(f"Failed to add interest: {e}")
         return False
···
 async def update_current_state(memory: NamespaceMemory, reflection: str) -> bool:
     """Update self-reflection - freely allowed"""
     try:
-        new_content = f"## current state\n\n{reflection}\n\n_Last updated: {datetime.now().isoformat()}_"
-        
+        # Just store the reflection, no formatting or headers
         await memory.store_core_memory(
-            "current_state",
-            new_content,
-            MemoryType.PERSONALITY
+            "current_state", reflection, MemoryType.PERSONALITY
         )
-        
+
         logger.info("Updated current state")
         return True
-        
+
     except Exception as e:
         logger.error(f"Failed to update state: {e}")
         return False
 
 
-async def propose_style_change(memory: NamespaceMemory, aspect: str, change: str, reason: str) -> str:
-    """Propose communication style change - guided evolution"""
-    # Validate it stays within character
-    if not is_style_change_valid(aspect, change):
-        return "This change would conflict with my core identity"
-    
-    proposal_id = f"style_{datetime.now().timestamp()}"
-    
-    # Store proposal
-    await memory.store_core_memory(
-        f"proposal_{proposal_id}",
-        f"Aspect: {aspect}\nChange: {change}\nReason: {reason}",
-        MemoryType.SYSTEM
-    )
-    
-    return proposal_id
+# Note: propose_style_change was removed because the validation logic was broken.
+# Style changes should be handled through the approval system like other guided changes.
 
 
-def is_style_change_valid(aspect: str, change: str) -> bool:
-    """Check if a style change maintains character coherence"""
-    # Reject changes that would fundamentally alter character
-    invalid_changes = [
-        "aggressive", "confrontational", "formal", "verbose",
-        "emoji-heavy", "ALL CAPS", "impersonal", "robotic"
-    ]
-    
-    change_lower = change.lower()
-    return not any(invalid in change_lower for invalid in invalid_changes)
+def request_operator_approval(
+    section: str, change: str, reason: str, thread_uri: str | None = None
+) -> int:
+    """Request approval for operator-only changes
 
+    Args:
+        section: Personality section to change
+        change: The proposed change
+        reason: Why this change is needed
+        thread_uri: Optional thread URI to notify after approval
 
-def request_operator_approval(section: str, change: str, reason: str) -> int:
-    """Request approval for operator-only changes
-    
     Returns approval request ID (0 if no approval needed)
     """
     if not needs_approval(section):
         return 0
-        
+
     from bot.core.dm_approval import create_approval_request
-    
+
     return create_approval_request(
         request_type="personality_change",
         request_data={
             "section": section,
             "change": change,
             "reason": reason,
-            "description": f"Change {section}: {change[:50]}..."
-        }
+            "description": f"Change {section}: {change[:50]}...",
+        },
+        thread_uri=thread_uri,
     )
 
 
 async def process_approved_changes(memory: NamespaceMemory) -> int:
     """Process any approved personality changes
-    
+
     Returns number of changes processed
     """
     import json
+
     from bot.database import thread_db
-    
+
     processed = 0
     # Get recently approved personality changes that haven't been applied yet
     with thread_db._get_connection() as conn:
···
             """
         )
         approvals = [dict(row) for row in cursor.fetchall()]
-    
+
     for approval in approvals:
-            try:
-                data = json.loads(approval["request_data"])
-                section = data["section"]
-                change = data["change"]
+        try:
+            data = json.loads(approval["request_data"])
+            section = data["section"]
+            change = data["change"]
+
+            # Apply the personality change
+            if section in ["core_identity", "boundaries", "communication_style"]:
+                # Apply the approved change
+                await memory.store_core_memory(section, change, MemoryType.PERSONALITY)
+
+                # Log the change with appropriate description
+                log_entry = f"[{datetime.now().isoformat()}] "
+                if section == "communication_style":
+                    log_entry += f"Applied guided evolution to {section}"
+                else:
+                    log_entry += f"Operator approved change to {section}"
                 
-                # Apply the personality change
-                if section in ["core_identity", "boundaries"]:
-                    # These are critical sections - update directly
-                    await memory.store_core_memory(
-                        section,
-                        change,
-                        MemoryType.PERSONALITY
-                    )
-                    
-                    # Log the change
-                    await memory.store_core_memory(
-                        "evolution_log",
-                        f"[{datetime.now().isoformat()}] Operator approved change to {section}",
-                        MemoryType.SYSTEM
+                await memory.store_core_memory(
+                    "evolution_log",
+                    log_entry,
+                    MemoryType.SYSTEM,
+                )
+
+                processed += 1
+                logger.info(f"Applied approved change to {section}")
+
+                # Mark as applied
+                with thread_db._get_connection() as conn:
+                    conn.execute(
+                        "UPDATE approval_requests SET applied_at = CURRENT_TIMESTAMP WHERE id = ?",
+                        (approval["id"],),
                     )
-                    
-                    processed += 1
-                    logger.info(f"Applied approved change to {section}")
-                    
-                    # Mark as applied
-                    with thread_db._get_connection() as conn:
-                        conn.execute(
-                            "UPDATE approval_requests SET applied_at = CURRENT_TIMESTAMP WHERE id = ?",
-                            (approval['id'],)
-                        )
-                    
-            except Exception as e:
-                logger.error(f"Failed to process approval #{approval['id']}: {e}")
-    
-    return processed
+
+        except Exception as e:
+            logger.error(f"Failed to process approval #{approval['id']}: {e}")
+
+    return processed

src/bot/response_generator.py

···
 """Response generation for the bot"""
 
 import logging
-import os
 import random
 
+from bot.agents._personality import load_dynamic_personality, load_personality
 from bot.config import settings
-from bot.memory import MemoryType, NamespaceMemory
+from bot.memory import MemoryType
 from bot.status import bot_status
+from bot.ui.context_capture import context_capture
 
 logger = logging.getLogger("bot.response")
 
···
                 self.memory = None
 
     async def generate(
-        self, mention_text: str, author_handle: str, thread_context: str = ""
+        self, mention_text: str, author_handle: str, thread_context: str = "", thread_uri: str | None = None
     ):
         """Generate a response to a mention"""
+        # Capture context components for visualization
+        components = []
+        
+        # 1. Base personality (always present)
+        base_personality = load_personality()
+        components.append({
+            "name": "Base Personality",
+            "type": "personality",
+            "content": base_personality,
+            "metadata": {"source": "personalities/phi.md"}
+        })
+        
         # Enhance thread context with memory if available
         enhanced_context = thread_context
 
         if self.memory and self.agent:
             try:
+                # 2. Dynamic personality memories
+                dynamic_personality = await load_dynamic_personality()
+                components.append({
+                    "name": "Dynamic Personality",
+                    "type": "personality", 
+                    "content": dynamic_personality,
+                    "metadata": {"source": "TurboPuffer core memories"}
+                })
+                
                 # Store the incoming message
                 await self.memory.store_user_memory(
                     author_handle,
···
                     MemoryType.CONVERSATION,
                 )
 
-                # Build conversation context
+                # Build conversation context with semantic search
                 memory_context = await self.memory.build_conversation_context(
-                    author_handle, include_core=True
+                    author_handle, include_core=True, query=mention_text
                 )
                 enhanced_context = f"{thread_context}\n\n{memory_context}".strip()
                 logger.info("📚 Enhanced context with memories")
+                
+                # 3. User-specific memories (if any)
+                user_memories = await self.memory.build_conversation_context(author_handle, include_core=False, query=mention_text)
+                if user_memories and user_memories.strip():
+                    components.append({
+                        "name": f"User Memories (@{author_handle})",
+                        "type": "memory",
+                        "content": user_memories,
+                        "metadata": {"user": author_handle, "source": "TurboPuffer user namespace"}
+                    })
 
             except Exception as e:
                 logger.warning(f"Memory enhancement failed: {e}")
 
+        # 4. Thread context (if available)
+        if thread_context and thread_context != "No previous messages in this thread.":
+            components.append({
+                "name": "Thread Context",
+                "type": "thread",
+                "content": thread_context,
+                "metadata": {"thread_uri": thread_uri}
+            })
+
+        # 5. Current mention
+        components.append({
+            "name": "Current Mention",
+            "type": "mention",
+            "content": f"@{author_handle} said: {mention_text}",
+            "metadata": {"author": author_handle, "thread_uri": thread_uri}
+        })
+
         if self.agent:
             response = await self.agent.generate_response(
-                mention_text, author_handle, enhanced_context
+                mention_text, author_handle, enhanced_context, thread_uri
             )
 
             # Store bot's response in memory if available
···
                 except Exception as e:
                     logger.warning(f"Failed to store bot response: {e}")
 
+            # Capture context for visualization
+            response_text = response.text if hasattr(response, 'text') else str(response.get('text', '[no text]'))
+            context_capture.capture_response_context(
+                mention_text=mention_text,
+                author_handle=author_handle,
+                thread_uri=thread_uri,
+                generated_response=response_text,
+                components=components
+            )
+
             return response
         else:
             # Return a simple dict for placeholder responses
-            return {"action": "reply", "text": random.choice(PLACEHOLDER_RESPONSES)}
+            placeholder_text = random.choice(PLACEHOLDER_RESPONSES)
+            
+            # Still capture context for placeholders
+            context_capture.capture_response_context(
+                mention_text=mention_text,
+                author_handle=author_handle,
+                thread_uri=thread_uri,
+                generated_response=placeholder_text,
+                components=components
+            )
+            
+            return {"action": "reply", "text": placeholder_text}

src/bot/services/message_handler.py

···
     async def handle_mention(self, notification):
         """Process a mention or reply notification"""
         try:
-            logger.debug(f"📨 Processing notification: reason={notification.reason}, uri={notification.uri}")
-            
             # Skip if not a mention or reply
             if notification.reason not in ["mention", "reply"]:
-                logger.debug(f"⏭️  Skipping notification with reason: {notification.reason}")
                 return
 
             post_uri = notification.uri
···
             author_handle = post.author.handle
             author_did = post.author.did
             
-            logger.debug(f"📝 Post details: author=@{author_handle}, text='{mention_text}'")
-
             # Record mention received
             bot_status.record_mention()
 
···
                 mention_text=mention_text,
                 author_handle=author_handle,
                 thread_context=thread_context,
+                thread_uri=thread_uri,
             )
 
             # Handle structured response or legacy dict

src/bot/services/notification_poller.py

···
 import asyncio
+import json
 import logging
 import time
 
···
             try:
                 await self._check_notifications()
             except Exception as e:
+                # Compact error handling (12-factor principle #9)
                 logger.error(f"Error in notification poll: {e}")
                 bot_status.record_error()
                 if settings.debug:
                     import traceback
-
                     traceback.print_exc()
+                # Continue polling - don't let one error stop the bot
+                continue
 
             # Sleep with proper cancellation handling
             try:
···
         for notification in reversed(notifications):
             # Skip if already seen or processed
             if notification.is_read or notification.uri in self._processed_uris:
-                logger.debug(f"⏭️  Skipping already processed: {notification.uri}")
                 continue
 
-            logger.debug(f"🔍 Found notification: reason={notification.reason}, uri={notification.uri}")
-            
             if notification.reason in ["mention", "reply"]:
+                logger.debug(f"🔍 Processing {notification.reason} notification")
                 # Process mentions and replies in threads
                 self._processed_uris.add(notification.uri)
                 await self.handler.handle_mention(notification)
                 processed_any_mentions = True
             else:
-                logger.debug(f"⏭️  Ignoring notification type: {notification.reason}")
+                # Silently ignore other notification types
+                pass
 
         # Mark all notifications as seen using the initial timestamp
         # This ensures we don't miss any that arrived during processing
···
             from bot.core.dm_approval import process_dm_for_approval, check_pending_approvals, notify_operator_of_pending
             from bot.personality import process_approved_changes
             
-            # Check if we have pending approvals
+            # Check if we have pending approvals (include all for DM checking)
             pending = check_pending_approvals()
             if not pending:
                 return
             
-            logger.debug(f"Checking DMs for {len(pending)} pending approvals")
+            # Check DMs for pending approvals
             
             # Get recent DMs
             chat_client = self.client.client.with_bsky_chat_proxy()
···
                             break
                     
                     if sender_handle:
-                        logger.debug(f"DM from @{sender_handle}: {msg.text[:50]}...")
+                        # Process DM from operator
                         # Mark this message as processed
                         self._processed_dm_ids.add(msg.id)
                         
···
                                 chat_client.chat.bsky.convo.update_read(
                                     data={"convoId": convo.id}
                                 )
-                                logger.debug(f"Marked conversation {convo.id} as read")
+                                pass  # Successfully marked as read
                             except Exception as e:
                                 logger.warning(f"Failed to mark conversation as read: {e}")
             
···
                 changes = await process_approved_changes(self.handler.response_generator.memory)
                 if changes:
                     logger.info(f"Applied {changes} approved personality changes")
+                
+                # Notify threads about applied changes
+                await self._notify_threads_about_approvals()
             
             # Notify operator of new pending approvals
-            if len(pending) > 0:
-                await notify_operator_of_pending(self.client, self._notified_approval_ids)
-                # Add all pending IDs to notified set
-                for approval in pending:
-                    self._notified_approval_ids.add(approval["id"])
+            # Use database to track what's been notified instead of in-memory set
+            from bot.database import thread_db
+            unnotified = thread_db.get_pending_approvals(include_notified=False)
+            if unnotified:
+                await notify_operator_of_pending(self.client, None)  # Let DB handle tracking
+                # Mark as notified in database
+                thread_db.mark_operator_notified([a["id"] for a in unnotified])
                 
         except Exception as e:
             logger.warning(f"DM approval check failed: {e}")
+    
+    async def _notify_threads_about_approvals(self):
+        """Notify threads about applied personality changes"""
+        try:
+            from bot.database import thread_db
+            import json
+            
+            # Get approvals that need notification
+            approvals = thread_db.get_recently_applied_approvals()
+            
+            for approval in approvals:
+                try:
+                    data = json.loads(approval["request_data"])
+                    
+                    # Create notification message
+                    message = f"✅ personality update applied: {data.get('section', 'unknown')} has been updated"
+                    
+                    # Get the original post to construct proper reply
+                    from atproto_client import models
+                    thread_uri = approval["thread_uri"]
+                    
+                    # Get the post data to extract CID
+                    posts_response = self.client.client.get_posts([thread_uri])
+                    if not posts_response.posts:
+                        logger.error(f"Could not find post at {thread_uri}")
+                        continue
+                    
+                    original_post = posts_response.posts[0]
+                    
+                    # Create StrongRef with the actual CID
+                    parent_ref = models.ComAtprotoRepoStrongRef.Main(
+                        uri=thread_uri, cid=original_post.cid
+                    )
+                    
+                    # For thread notifications, parent and root are the same
+                    reply_ref = models.AppBskyFeedPost.ReplyRef(
+                        parent=parent_ref, root=parent_ref
+                    )
+                    
+                    # Post to the thread
+                    await self.client.create_post(
+                        text=message,
+                        reply_to=reply_ref
+                    )
+                    
+                    # Mark as notified
+                    thread_db.mark_approval_notified(approval["id"])
+                    logger.info(f"Notified thread about approval #{approval['id']}")
+                    
+                except Exception as e:
+                    logger.error(f"Failed to notify thread for approval #{approval['id']}: {e}")
+                    
+        except Exception as e:
+            logger.warning(f"Thread notification check failed: {e}")

src/bot/templates.py

···
-"""HTML templates for the bot"""
-
-STATUS_PAGE_TEMPLATE = """<!DOCTYPE html>
-<html>
-<head>
-    <title>{bot_name} Status</title>
-    <meta http-equiv="refresh" content="10">
-    <style>
-        body {{
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-            margin: 0;
-            padding: 20px;
-            background: #0a0a0a;
-            color: #e0e0e0;
-        }}
-        .container {{
-            max-width: 800px;
-            margin: 0 auto;
-        }}
-        h1 {{
-            color: #00a8ff;
-            margin-bottom: 30px;
-        }}
-        .status-grid {{
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-            gap: 20px;
-            margin-bottom: 30px;
-        }}
-        .status-card {{
-            background: #1a1a1a;
-            border: 1px solid #333;
-            border-radius: 8px;
-            padding: 20px;
-        }}
-        .status-card h3 {{
-            margin: 0 0 15px 0;
-            color: #00a8ff;
-            font-size: 14px;
-            text-transform: uppercase;
-            letter-spacing: 1px;
-        }}
-        .status-value {{
-            font-size: 24px;
-            font-weight: bold;
-            margin-bottom: 5px;
-        }}
-        .status-label {{
-            font-size: 12px;
-            color: #888;
-        }}
-        .status-indicator {{
-            display: inline-block;
-            width: 10px;
-            height: 10px;
-            border-radius: 50%;
-            margin-right: 8px;
-        }}
-        .status-active {{
-            background: #4caf50;
-        }}
-        .status-inactive {{
-            background: #f44336;
-        }}
-        .footer {{
-            text-align: center;
-            color: #666;
-            font-size: 12px;
-            margin-top: 40px;
-        }}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>🤖 {bot_name} Status</h1>
-        
-        <div class="status-grid">
-            <div class="status-card">
-                <h3>Bot Status</h3>
-                <div class="status-value">
-                    <span class="status-indicator {status_class}"></span>
-                    {status_text}
-                </div>
-                <div class="status-label">@{handle}</div>
-            </div>
-            
-            <div class="status-card">
-                <h3>Uptime</h3>
-                <div class="status-value">{uptime}</div>
-                <div class="status-label">Since startup</div>
-            </div>
-            
-            <div class="status-card">
-                <h3>Activity</h3>
-                <div class="status-value">{mentions_received}</div>
-                <div class="status-label">Mentions received</div>
-                <div style="margin-top: 10px;">
-                    <div class="status-value">{responses_sent}</div>
-                    <div class="status-label">Responses sent</div>
-                </div>
-            </div>
-            
-            <div class="status-card">
-                <h3>Response Mode</h3>
-                <div class="status-value">
-                    {ai_mode}
-                </div>
-                <div class="status-label">
-                    {ai_description}
-                </div>
-            </div>
-            
-            <div class="status-card">
-                <h3>Last Activity</h3>
-                <div style="margin-bottom: 10px;">
-                    <div class="status-label">Last mention</div>
-                    <div>{last_mention}</div>
-                </div>
-                <div>
-                    <div class="status-label">Last response</div>
-                    <div>{last_response}</div>
-                </div>
-            </div>
-            
-            <div class="status-card">
-                <h3>Health</h3>
-                <div class="status-value">{errors}</div>
-                <div class="status-label">Errors encountered</div>
-            </div>
-        </div>
-        
-        <div class="footer">
-            <p>Auto-refreshes every 10 seconds</p>
-        </div>
-    </div>
-</body>
-</html>"""

src/bot/tools/google_search.py

···
+import logging
+
 import httpx
 
 from bot.config import settings
+
+logger = logging.getLogger("bot.tools")
 
 
 async def search_google(query: str, num_results: int = 3) -> str:
···
             return "\n\n".join(results) if results else "No search results found"
 
         except Exception as e:
-            return f"Search error: {str(e)}"
+            logger.error(f"Search failed: {e}")
+            # 12-factor principle #4: Tools should throw errors, not return error strings
+            raise

src/bot/tools/personality_tools.py

···
-"""Personality introspection tools for the agent"""
-
-import logging
-from typing import Literal
-
-from bot.memory import NamespaceMemory
-from bot.personality import add_interest, update_current_state
-
-logger = logging.getLogger("bot.personality_tools")
-
-PersonalitySection = Literal["interests", "current_state", "communication_style", "core_identity", "boundaries"]
-
-
-async def view_personality_section(memory: NamespaceMemory, section: PersonalitySection) -> str:
-    """View a section of my personality"""
-    try:
-        memories = await memory.get_core_memories()
-        
-        # Find the requested section
-        for mem in memories:
-            if mem.metadata.get("label") == section:
-                return mem.content
-                
-        return f"Section '{section}' not found in my personality"
-        
-    except Exception as e:
-        logger.error(f"Failed to view personality: {e}")
-        return "Unable to access personality data"
-
-
-async def reflect_on_interest(memory: NamespaceMemory, topic: str, reflection: str) -> str:
-    """Reflect on a potential new interest"""
-    # Check if this is genuinely interesting based on context
-    if len(reflection) < 20:
-        return "Need more substantial reflection to add an interest"
-        
-    # Add the interest
-    success = await add_interest(memory, topic, reflection)
-    
-    if success:
-        return f"Added '{topic}' to my interests based on: {reflection}"
-    else:
-        return "Failed to update interests"
-
-
-async def update_self_reflection(memory: NamespaceMemory, reflection: str) -> str:
-    """Update my current state/self-reflection"""
-    if len(reflection) < 50:
-        return "Reflection too brief to warrant an update"
-        
-    success = await update_current_state(memory, reflection)
-    
-    if success:
-        return "Updated my current state reflection"
-    else:
-        return "Failed to update reflection"

src/bot/ui/context_capture.py

···
+"""Context capture system for visualizing phi's response context"""
+
+import logging
+from collections import deque
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from typing import Any, Literal
+
+logger = logging.getLogger("bot.context")
+
+
+@dataclass
+class ContextComponent:
+    """A component of phi's response context"""
+
+    name: str
+    type: Literal["personality", "memory", "thread", "mention", "user"]
+    content: str
+    size_chars: int
+    metadata: dict[str, Any]
+    timestamp: str
+
+
+@dataclass
+class ResponseContext:
+    """Complete context for a single response"""
+
+    response_id: str
+    mention_text: str
+    author_handle: str
+    thread_uri: str | None
+    generated_response: str
+    components: list[ContextComponent]
+    total_context_chars: int
+    timestamp: str
+
+
+class ContextCapture:
+    """Captures and stores context information for responses"""
+
+    def __init__(self, max_stored: int = 50):
+        self.max_stored = max_stored
+        self.responses: deque = deque(maxlen=max_stored)
+
+    def capture_response_context(
+        self,
+        mention_text: str,
+        author_handle: str,
+        thread_uri: str | None,
+        generated_response: str,
+        components: list[dict[str, Any]],
+    ) -> str:
+        """Capture context for a response and return unique ID"""
+        response_id = f"resp_{datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
+
+        # Convert components to ContextComponent objects
+        context_components = []
+        total_chars = 0
+
+        for comp in components:
+            component = ContextComponent(
+                name=comp["name"],
+                type=comp["type"],
+                content=comp["content"],
+                size_chars=len(comp["content"]),
+                metadata=comp.get("metadata", {}),
+                timestamp=datetime.now().isoformat(),
+            )
+            context_components.append(component)
+            total_chars += component.size_chars
+
+        # Create response context
+        response_context = ResponseContext(
+            response_id=response_id,
+            mention_text=mention_text,
+            author_handle=author_handle,
+            thread_uri=thread_uri,
+            generated_response=generated_response,
+            components=context_components,
+            total_context_chars=total_chars,
+            timestamp=datetime.now().isoformat(),
+        )
+
+        # Store it
+        self.responses.appendleft(response_context)
+
+        logger.info(
+            f"📊 Captured context for {response_id}: {len(components)} components, {total_chars} chars"
+        )
+        return response_id
+
+    def get_response_context(self, response_id: str) -> ResponseContext | None:
+        """Get context for a specific response"""
+        for resp in self.responses:
+            if resp.response_id == response_id:
+                return resp
+        return None
+
+    def get_recent_responses(self, limit: int = 20) -> list[ResponseContext]:
+        """Get recent response contexts"""
+        return list(self.responses)[:limit]
+
+    def to_dict(self, response_context: ResponseContext) -> dict[str, Any]:
+        """Convert ResponseContext to dictionary for JSON serialization"""
+        return asdict(response_context)
+
+
+# Global instance
+context_capture = ContextCapture()

src/bot/ui/templates.py

···
+"""HTML templates for the bot"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from bot.ui.context_capture import ResponseContext
+
+CONTEXT_VISUALIZATION_TEMPLATE = """<!DOCTYPE html>
+<html>
+<head>
+    <title>Phi Context Visualization</title>
+    <style>
+        body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; background: #0a0a0a; color: #e0e0e0; }}
+        .response-card {{ border: 1px solid #333; margin-bottom: 20px; border-radius: 8px; overflow: hidden; background: #1a1a1a; }}
+        .response-header {{ background: #2a2a2a; padding: 15px; border-bottom: 1px solid #333; }}
+        .response-meta {{ font-size: 0.9em; color: #888; margin-bottom: 5px; }}
+        .mention-text {{ font-weight: bold; margin-bottom: 5px; color: #e0e0e0; }}
+        .generated-response {{ color: #00a8ff; font-style: italic; }}
+        .components {{ padding: 15px; }}
+        .component {{ margin-bottom: 15px; }}
+        .component-header {{ 
+            cursor: pointer; 
+            padding: 10px; 
+            background: #2a2a2a; 
+            border: 1px solid #444; 
+            border-radius: 4px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }}
+        .component-header:hover {{ background: #333; }}
+        .component-type {{ 
+            font-size: 0.8em; 
+            color: #888; 
+            background: #444; 
+            padding: 2px 6px; 
+            border-radius: 3px; 
+        }}
+        .component-size {{ font-size: 0.8em; color: #888; }}
+        .component-content {{ 
+            display: none; 
+            padding: 15px; 
+            border: 1px solid #444; 
+            border-top: none; 
+            background: #1a1a1a; 
+            white-space: pre-wrap; 
+            font-family: 'SF Mono', Monaco, 'Cascadia Code', monospace; 
+            font-size: 0.9em;
+            max-height: 400px;
+            overflow-y: auto;
+        }}
+        .component-content.show {{ display: block; }}
+        .stats {{ display: flex; gap: 20px; margin-bottom: 10px; }}
+        .stat {{ font-size: 0.9em; color: #888; }}
+        h1 {{ color: #00a8ff; }}
+    </style>
+</head>
+<body>
+    <h1>🧠 Phi Context Visualization</h1>
+    {responses_html}
+    <script>
+        function toggleComponent(id) {{
+            const element = document.getElementById(id);
+            element.classList.toggle('show');
+        }}
+    </script>
+</body>
+</html>"""
+
+STATUS_PAGE_TEMPLATE = """<!DOCTYPE html>
+<html>
+<head>
+    <title>Bluesky Bot Status</title>
+    <meta http-equiv="refresh" content="10">
+    <style>
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            margin: 0;
+            padding: 20px;
+            background: #0a0a0a;
+            color: #e0e0e0;
+        }}
+        .container {{
+            max-width: 800px;
+            margin: 0 auto;
+        }}
+        h1 {{
+            color: #00a8ff;
+            margin-bottom: 30px;
+        }}
+        .status-grid {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 20px;
+            margin-bottom: 40px;
+        }}
+        .status-card {{
+            background: #1a1a1a;
+            border: 1px solid #333;
+            border-radius: 8px;
+            padding: 20px;
+        }}
+        .status-card h3 {{
+            margin: 0 0 15px 0;
+            color: #00a8ff;
+            font-size: 1rem;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }}
+        .status-value {{
+            font-size: 2rem;
+            font-weight: bold;
+            margin-bottom: 5px;
+        }}
+        .status-label {{
+            color: #888;
+            font-size: 0.9rem;
+        }}
+        .status-active {{
+            color: #00ff88;
+        }}
+        .status-inactive {{
+            color: #ff4444;
+        }}
+        .uptime {{
+            font-size: 1.2rem;
+            margin-bottom: 5px;
+        }}
+        .ai-mode {{
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 4px;
+            font-size: 0.9rem;
+            background: #00a8ff22;
+            color: #00a8ff;
+            border: 1px solid #00a8ff44;
+        }}
+        .ai-mode.placeholder {{
+            background: #ff444422;
+            color: #ff8888;
+            border-color: #ff444444;
+        }}
+        .footer {{
+            margin-top: 40px;
+            text-align: center;
+            color: #666;
+            font-size: 0.9rem;
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🤖 {bot_name} Status</h1>
+        
+        <div class="status-grid">
+            <div class="status-card">
+                <h3>Bot Status</h3>
+                <div class="status-value {status_class}">{status}</div>
+                <div class="uptime">{uptime}</div>
+                <div style="margin-top: 10px;">
+                    <span class="ai-mode {ai_mode_class}">{ai_mode}</span>
+                </div>
+            </div>
+            
+            <div class="status-card">
+                <h3>Activity</h3>
+                <div class="status-value">{mentions}</div>
+                <div class="status-label">Mentions received</div>
+                <div style="margin-top: 10px;">
+                    <div class="status-value">{responses}</div>
+                    <div class="status-label">Responses sent</div>
+                </div>
+            </div>
+            
+            <div class="status-card">
+                <h3>Last Activity</h3>
+                <div style="margin-bottom: 10px;">
+                    <div class="status-label">Last mention</div>
+                    <div>{last_mention}</div>
+                </div>
+                <div>
+                    <div class="status-label">Last response</div>
+                    <div>{last_response}</div>
+                </div>
+            </div>
+            
+            <div class="status-card">
+                <h3>Health</h3>
+                <div class="status-value">{errors}</div>
+                <div class="status-label">Errors encountered</div>
+            </div>
+        </div>
+        
+        <div class="footer">
+            <p>Auto-refreshes every 10 seconds</p>
+        </div>
+    </div>
+</body>
+</html>"""
+
+
+def build_response_cards_html(responses: list["ResponseContext"]) -> str:
+    """Build HTML for response cards"""
+    if not responses:
+        return '<p style="text-align: center; color: #888;">No recent responses to display.</p>'
+    
+    return "".join([
+        f'''
+        <div class="response-card">
+            <div class="response-header">
+                <div class="response-meta">
+                    {resp.timestamp[:19].replace("T", " ")} • @{resp.author_handle}
+                    {f" • Thread: {resp.thread_uri.split('/')[-1][:8]}..." if resp.thread_uri else ""}
+                </div>
+                <div class="mention-text">"{resp.mention_text}"</div>
+                <div class="generated-response">→ "{resp.generated_response}"</div>
+                <div class="stats">
+                    <div class="stat">{len(resp.components)} components</div>
+                    <div class="stat">{resp.total_context_chars:,} characters</div>
+                </div>
+            </div>
+            <div class="components">
+                {"".join([
+                    f'''
+                <div class="component">
+                    <div class="component-header" onclick="toggleComponent('{resp.response_id}_{i}')">
+                        <div>
+                            <strong>{comp.name}</strong>
+                            <span class="component-type">{comp.type}</span>
+                        </div>
+                        <div class="component-size">{comp.size_chars:,} chars</div>
+                    </div>
+                    <div class="component-content" id="{resp.response_id}_{i}">
+{comp.content}
+                    </div>
+                </div>
+                '''
+                    for i, comp in enumerate(resp.components)
+                ])}
+            </div>
+        </div>
+        '''
+        for resp in responses
+    ])