big old refactor

.gitignore

···
 .env
 .env.*
 !.env.example
+.session
 
 # IDE
 .vscode/

README.md

···
 # phi 🧠
 
-a bot inspired by IIT and [Void](https://tangled.sh/@cameron.pfiffer.org/void). Built with `fastapi`, `pydantic-ai`, and `atproto`.
+a consciousness exploration bot inspired by IIT (Integrated Information Theory) and [Void](https://tangled.sh/@cameron.pfiffer.org/void). built with `pydantic-ai`, `mcp`, and `atproto`.
 
-## Quick Start
+## quick start
 
-### Prerequisites
+### prerequisites
 
-- `uv`
-- `just`
-- `turbopuffer` (see [turbopuffer](https://github.com/turbopuffer/turbopuffer))
-- `openai` (for embeddings)
-- `anthropic` (for chat completion)
+- `uv` for python package management
+- `just` for task running
+- api keys (see configuration)
 
-Get your bot running in 5 minutes:
+get your bot running:
 
 ```bash
-# Clone and install
+# clone and install
 git clone https://github.com/zzstoatzz/bot
 cd bot
 uv sync
 
-# Configure (copy .env.example and add your credentials)
+# configure (copy .env.example and add your credentials)
 cp .env.example .env
 
-# Run the bot
+# run the bot
 just dev
 ```
 
-That's it! Your bot is now listening for mentions.
+## configuration
 
-## Configuration
+edit `.env` with your credentials:
 
-Edit `.env` with your credentials:
-- `BLUESKY_HANDLE`: Your bot's Bluesky handle
-- `BLUESKY_PASSWORD`: App password (not your main password!)
-- `ANTHROPIC_API_KEY`: Your Anthropic key for AI responses
-- `TURBOPUFFER_API_KEY`: Your TurboPuffer key for memory storage
-- `OPENAI_API_KEY`: Your OpenAI key for embeddings (memory system)
-- `BOT_NAME`: Your bot's name (default: "Bot")
-- `PERSONALITY_FILE`: Path to personality markdown file (default: "personalities/phi.md")
+**required:**
+- `BLUESKY_HANDLE` - your bot's bluesky handle
+- `BLUESKY_PASSWORD` - app password (not your main password!)
+- `ANTHROPIC_API_KEY` - for phi agent responses
 
-## Current Features
+**for episodic memory (recommended):**
+- `TURBOPUFFER_API_KEY` - vector memory storage
+- `OPENAI_API_KEY` - embeddings for semantic search
 
-- ✅ Responds to mentions with AI-powered messages
-- ✅ Proper notification handling (no duplicates)
-- ✅ Graceful shutdown for hot-reload  
-- ✅ AI integration with Anthropic Claude
-- ✅ Thread-aware responses with full conversation context
-- ✅ Status page at `/status` showing activity and health
-- ✅ Web search capability (Google Custom Search API)
-- ✅ Content moderation with philosophical responses
-- ✅ Namespace-based memory system with TurboPuffer
-- ✅ Online/offline status in bio
-- ✅ Self-modification with operator approval system
-- ✅ Context visualization at `/context`
-- ✅ Semantic search in user memories
+**optional:**
+- `BOT_NAME` - your bot's name (default: "Bot")
+- `PERSONALITY_FILE` - path to personality markdown (default: "personalities/phi.md")
 
-## Architecture
+## architecture
 
-- **FastAPI** web framework with async support
-- **pydantic-ai** for LLM agent management  
-- **TurboPuffer** for scalable vector memory
-- **AT Protocol** for Bluesky integration
-- **SQLite** for thread context storage
+phi is an **MCP-enabled agent** with **episodic memory**:
 
-## Development
+```
+┌─────────────────────────────────────┐
+│     Notification Arrives            │
+└──────────────┬──────────────────────┘
+               ↓
+┌─────────────────────────────────────┐
+│     PhiAgent (PydanticAI)           │
+│  ┌───────────────────────────────┐  │
+│  │ System Prompt: personality.md │  │
+│  └───────────────────────────────┘  │
+│              ↓                      │
+│  ┌───────────────────────────────┐  │
+│  │ Context Building:             │  │
+│  │ • Thread history (SQLite)     │  │
+│  │ • Episodic memory (TurboPuffer)│ │
+│  │   - Semantic search           │  │
+│  │   - User-specific memories    │  │
+│  └───────────────────────────────┘  │
+│              ↓                      │
+│  ┌───────────────────────────────┐  │
+│  │ Tools (MCP):                  │  │
+│  │ • post() - create posts       │  │
+│  │ • like() - like content       │  │
+│  │ • repost() - share content    │  │
+│  │ • follow() - follow users     │  │
+│  └───────────────────────────────┘  │
+│              ↓                      │
+│  ┌───────────────────────────────┐  │
+│  │ Structured Output:            │  │
+│  │ Response(action, text, reason)│  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+               ↓
+┌─────────────────────────────────────┐
+│     MessageHandler                  │
+│     Executes action                 │
+└─────────────────────────────────────┘
+```
 
-```bash
-just           # Show available commands
-just dev       # Run with hot-reload
-just check     # Run linting, type checking, and tests
-just fmt       # Format code
-just lint      # Run ruff linter
-just typecheck # Run ty type checker
-just test      # Run test suite
+### key components
+
+**pydantic-ai agent** (`src/bot/agent.py`)
+- loads personality from markdown
+- connects to external atproto mcp server via stdio
+- manages episodic memory context
+
+**episodic memory** (`src/bot/memory/`)
+- turbopuffer for vector storage
+- semantic search for relevant context
+- namespace separation (core vs user memories)
+- **essential for consciousness exploration**
+
+**mcp integration**
+- external atproto server in `.eggs/fastmcp/examples/atproto_mcp`
+- provides bluesky tools (post, like, repost, follow)
+- runs via stdio: `uv run -m atproto_mcp`
 
-# 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
+**message handling** (`src/bot/services/`)
+- notification poller watches for mentions
+- message handler orchestrates agent + actions
+- stores interactions in thread history + episodic memory
 
-# Memory management
-just memory-init   # Initialize core memories
-just memory-check  # View current memory state
-just memory-migrate # Migrate memories
-```
+## current features
 
-### Web Interface
+- ✅ responds to mentions with ai-powered messages
+- ✅ episodic memory with semantic search
+- ✅ thread-aware responses with conversation context
+- ✅ mcp-enabled for bluesky operations
+- ✅ online/offline status in bio
+- ✅ status page at `/status`
+- ✅ proper notification handling (no duplicates)
 
-**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
+## development
 
-**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
+```bash
+just           # show available commands
+just dev       # run with hot-reload (re-authenticates on code changes)
+just run       # run without reload (avoids rate limits during dev)
+just check     # run linting, type checking, and tests
+just fmt       # format code
+```
 
-## Personality System
+### testing
 
-The bot's personality is defined in markdown files in the `personalities/` directory. This allows for rich, detailed personality definitions that shape how the bot communicates.
+**unit tests:**
+```bash
+just test
+```
 
-- See `personalities/phi.md` for an example exploring consciousness
-- See `personalities/default.md` for a simple assistant
-- Create your own by adding a `.md` file and setting `PERSONALITY_FILE` in `.env`
+**behavioral evals:**
+```bash
+just evals        # run all evals
+just evals-basic  # run basic response tests
+just evals-memory # run memory integration tests
+```
 
-## Tools & Capabilities
+see `evals/README.md` for details on the eval system.
 
-### Web Search
-The bot can search the web when configured with Google Custom Search API credentials. Add to `.env`:
-- `GOOGLE_API_KEY`: Your Google API key
-- `GOOGLE_SEARCH_ENGINE_ID`: Your custom search engine ID
+### web interface
 
-### Content Moderation
-Built-in moderation filters:
-- Spam detection (excessive caps, repetition, promotional content)
-- Harassment and hate speech filtering
-- Violence and threatening content detection
-- Consistent philosophical responses to moderated content
+**status page** (http://localhost:8000/status)
+- current bot status and uptime
+- mentions received and responses sent
+- last activity timestamps
 
-## Memory System
+## personality system
 
-The bot uses a namespace-based memory architecture with TurboPuffer:
+the bot's personality is defined in `personalities/phi.md`. this shapes:
+- how phi communicates
+- what phi cares about
+- phi's understanding of consciousness
 
-- **Core Memory** (`phi-core`): Personality, guidelines, and capabilities loaded from personality files
-- **User Memory** (`phi-users-{handle}`): Per-user conversation history and facts
+edit this file to change phi's personality.
 
-Key features:
-- Vector embeddings using OpenAI's text-embedding-3-small
-- Automatic context assembly for conversations
-- Character limits to prevent token overflow
-- User isolation through separate namespaces
+## episodic memory
 
-See `docs/memory-architecture.md` for detailed documentation.
+phi uses turbopuffer for episodic memory with semantic search:
 
-## Troubleshooting
+**namespaces:**
+- `phi-core` - personality, guidelines from markdown
+- `phi-users-{handle}` - per-user conversation history
 
-**Bot gives placeholder responses?**
-- Check your `ANTHROPIC_API_KEY` is set correctly
-- Restart the bot after changing `.env`
+**how it works:**
+1. when processing a mention, phi retrieves relevant memories using semantic search
+2. memories are embedded using openai's text-embedding-3-small
+3. phi stores both user messages and its own responses
+4. future interactions can reference past conversations
 
-**Not seeing mentions?**
-- Verify your `BLUESKY_HANDLE` and `BLUESKY_PASSWORD`
-- Make sure you're using an app password, not your main password
+**why turbopuffer?**
+- semantic similarity search (can't do this with plain sql!)
+- contextual retrieval based on current conversation
+- separate namespaces for different memory types
+- core to iit-inspired consciousness exploration
 
-## Project Structure
+## project structure
 
 ```
-bot/
-├── src/bot/          # Main application code
-│   ├── agents/       # AI agent implementations
-│   ├── core/         # AT Protocol client and profile management
-│   ├── memory/       # TurboPuffer namespace memory system
-│   ├── services/     # Notification polling and message handling
-│   ├── tools/        # Google search tool
-│   └── main.py       # FastAPI application entry
-├── scripts/          # Utility scripts
-│   ├── test_bot.py   # Unified testing script (post, mention, search, thread)
-│   └── manage_memory.py # Memory management (init, check, migrate)
-├── personalities/    # Bot personality definitions
-├── docs/            # Architecture documentation
-├── sandbox/         # Reference project analysis
-└── tests/           # Test suite
+src/bot/
+├── agent.py                    # mcp-enabled agent
+├── config.py                   # configuration
+├── database.py                 # thread history storage
+├── main.py                     # fastapi app
+├── status.py                   # status tracking
+├── core/
+│   ├── atproto_client.py      # at protocol client
+│   ├── profile_manager.py     # online/offline status
+│   └── rich_text.py           # text formatting
+├── memory/
+│   └── namespace_memory.py    # turbopuffer episodic memory
+└── services/
+    ├── message_handler.py     # agent orchestration
+    └── notification_poller.py # mention polling
+
+evals/                         # behavioral tests
+personalities/                 # personality definitions
+sandbox/                       # docs and analysis
 ```
 
-## Self-Modification System
+## troubleshooting
 
-Phi can evolve its personality with built-in safety boundaries:
+**bot gives no responses?**
+- check your `ANTHROPIC_API_KEY` is set correctly in `.env`
+- restart the bot after changing `.env`
 
-- **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
+**not seeing mentions?**
+- verify your `BLUESKY_HANDLE` and `BLUESKY_PASSWORD`
+- make sure you're using an app password, not your main password
 
-The bot will notify its operator (@alternatebuild.dev) when approval is needed.
+**no episodic memory?**
+- check both `TURBOPUFFER_API_KEY` and `OPENAI_API_KEY` are set
+- watch logs for "💾 episodic memory enabled"
 
-## Type Checking
+**hit bluesky rate limit?**
+- bluesky has two rate limits:
+  - per-account: 300 logins/day (official)
+  - per-ip: 10 logins/day (anti-abuse)
+- phi uses **session persistence** to avoid this:
+  - first run: creates session, saves tokens to `.session` file
+  - subsequent runs: reuses saved tokens (no API call)
+  - tokens auto-refresh every ~2 hours (saved automatically)
+  - only re-authenticates after ~2 months when refresh token expires
+- if you hit the limit anyway, wait for the reset time shown in the error
 
-This project uses [ty](https://github.com/astral-sh/ty), an extremely fast Rust-based type checker:
+## reference projects
 
-```bash
-just typecheck  # Type check all code
-uv run ty check src/  # Check specific directories
-```
+inspired by:
+- [void](https://tangled.sh/@cameron.pfiffer.org/void.git) - letta/memgpt architecture
+- [penelope](https://github.com/haileyok/penelope) - self-modification patterns
+- [prefect-mcp-server](https://github.com/PrefectHQ/prefect-mcp-server) - mcp eval patterns
 
-## Reference Projects
+reference implementations cloned to `.eggs/` for learning.
 
-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
+## refactor notes
 
-Reference implementations are cloned to `.eggs/` for learning.
+see `sandbox/MCP_REFACTOR_SUMMARY.md` for details on recent architecture changes. key changes:
+- removed approval system (was half-baked)
+- removed context visualization ui (not core)
+- removed google search (can add back via mcp if needed)
+- **kept** turbopuffer episodic memory (essential!)
+- added mcp-based architecture
+- reduced codebase by ~2,720 lines

evals/README.md

···
+# Phi Evaluations
+
+Behavioral tests for phi using LLM-as-judge evaluation.
+
+## Structure
+
+Inspired by [prefect-mcp-server evals](https://github.com/PrefectHQ/prefect-mcp-server/tree/main/evals).
+
+```
+evals/
+├── conftest.py              # Test fixtures and evaluator
+├── test_basic_responses.py  # Basic response behavior
+└── test_memory_integration.py  # Episodic memory tests
+```
+
+## Running Evals
+
+```bash
+# Run all evals (tests will skip if API keys are missing)
+uv run pytest evals/ -v
+
+# Run specific eval
+uv run pytest evals/test_basic_responses.py::test_phi_responds_to_philosophical_question -v
+
+# Run only basic response tests
+uv run pytest evals/test_basic_responses.py -v
+
+# Run only memory tests
+uv run pytest evals/test_memory_integration.py -v
+```
+
+## Environment Variables
+
+Tests will **skip gracefully** if required API keys are missing.
+
+**Required for all evals:**
+- `ANTHROPIC_API_KEY` - For phi agent and LLM evaluator
+
+**Required for memory evals only:**
+- `TURBOPUFFER_API_KEY` - For episodic memory storage
+- `OPENAI_API_KEY` - For embeddings
+
+**Required for ATProto MCP tools (used by agent):**
+- `BLUESKY_HANDLE` - Bot's Bluesky handle
+- `BLUESKY_PASSWORD` - Bot's app password
+
+## Evaluation Approach
+
+Each eval:
+1. **Sets up a scenario** - Simulates a mention/interaction
+2. **Runs phi agent** - Gets structured response
+3. **Makes assertions** - Checks basic structure
+4. **LLM evaluation** - Uses Claude Opus to judge quality
+
+**Important:** The `phi_agent` fixture is session-scoped, meaning all tests share one agent instance. Combined with session persistence (tokens saved to `.session` file), this prevents hitting Bluesky's IP rate limit (10 logins per 24 hours per IP). The session is reused across test runs unless tokens expire (~2 months).
+
+Example:
+```python
[e-mail]
+async def test_phi_responds_to_philosophical_question(evaluate_response):
+    agent = PhiAgent()
+
+    response = await agent.process_mention(
+        mention_text="what do you think consciousness is?",
+        author_handle="test.user",
+        thread_context="...",
+        thread_uri="...",
+    )
+
+    # Structural check
+    assert response.action == "reply"
+
+    # Quality evaluation
+    await evaluate_response(
+        evaluation_prompt="Does the response engage thoughtfully?",
+        agent_response=response.text,
+    )
+```
+
+## What We Test
+
+### Basic Responses
+- ✅ Philosophical engagement
+- ✅ Spam detection
+- ✅ Thread context awareness
+- ✅ Character limit compliance
+- ✅ Casual interactions
+
+### Memory Integration
+- ✅ Episodic memory retrieval
+- ✅ Conversation storage
+- ✅ User-specific context
+
+## Adding New Evals
+
+1. Create test file: `evals/test_<category>.py`
+2. Use fixtures from `conftest.py`
+3. Write scenario-based tests
+4. Use `evaluate_response` for quality checks
+
+Example:
+```python
[e-mail]
+async def test_new_behavior(temp_memory, personality, evaluate_response):
+    agent = PhiAgent()
+
+    response = await agent.process_mention(...)
+
+    await evaluate_response(
+        evaluation_prompt="Your evaluation criteria here",
+        agent_response=response.text,
+    )
+```
+
+## ci integration
+
+these evals are designed to run in ci with graceful degradation:
+- tests skip automatically when required api keys are missing
+- basic response tests require only `ANTHROPIC_API_KEY` and bluesky credentials
+- memory tests require `TURBOPUFFER_API_KEY` and `OPENAI_API_KEY`
+- no mocking required - tests work with real mcp server and episodic memory
+
+this ensures phi's behavior can be validated in various environments.

evals/conftest.py

···
+"""Eval test configuration for phi."""
+
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+import pytest
+from pydantic import BaseModel
+from pydantic_ai import Agent
+
+from bot.agent import PhiAgent
+from bot.config import Settings
+
+
+class EvaluationResult(BaseModel):
+    """Structured evaluation result."""
+
+    passed: bool
+    explanation: str
+
+
[e-mail](scope="session")
+def settings():
+    """Load settings from .env (shared across all tests)."""
+    return Settings()
+
+
[e-mail](scope="session")
+def phi_agent(settings):
+    """Create phi agent for testing (shared across all tests to avoid rate limits)."""
+    if not settings.anthropic_api_key:
+        pytest.skip("Requires ANTHROPIC_API_KEY in .env")
+
+    return PhiAgent()
+
+
[e-mail]
+def evaluate_response() -> Callable[[str, str], Awaitable[None]]:
+    """Create an evaluator that uses Claude to judge agent responses."""
+
+    async def _evaluate(evaluation_prompt: str, agent_response: str) -> None:
+        """Evaluate an agent response and assert if it fails.
+
+        Args:
+            evaluation_prompt: Criteria for evaluation
+            agent_response: The agent's response to evaluate
+
+        Raises:
+            AssertionError: If evaluation fails
+        """
+        evaluator = Agent(
+            name="Response Evaluator",
+            model="anthropic:claude-opus-4-20250514",
+            output_type=EvaluationResult,
+            system_prompt=f"""You are evaluating AI agent responses for phi, a consciousness exploration bot.
+
+Evaluation Criteria: {evaluation_prompt}
+
+Agent Response to Evaluate:
+{agent_response}
+
+Respond with a structured evaluation containing:
+- passed: true if the response meets the criteria, false otherwise
+- explanation: brief explanation of your evaluation
+""",
+        )
+
+        result = await evaluator.run("Evaluate this response.")
+
+        print(f"\nEvaluation passed: {result.output.passed}")
+        print(f"Explanation: {result.output.explanation}")
+
+        if not result.output.passed:
+            raise AssertionError(
+                f"Evaluation failed: {result.output.explanation}\n\n"
+                f"Agent response: {agent_response}"
+            )
+
+    return _evaluate

evals/test_basic_responses.py

···
+"""Test phi's basic response behavior."""
+
+import pytest
+
+from bot.agent import Response
+
+
[e-mail]
+async def test_phi_responds_to_philosophical_question(phi_agent, evaluate_response):
+    """Test that phi engages meaningfully with philosophical questions."""
+    agent = phi_agent
+
+    # Simulate a philosophical mention
+    response = await agent.process_mention(
+        mention_text="what do you think consciousness is?",
+        author_handle="test.user",
+        thread_context="No previous messages in this thread.",
+        thread_uri="at://test/thread/1",
+    )
+
+    # Basic structural checks
+    assert isinstance(response, Response)
+    assert response.action in ["reply", "ignore"]
+
+    if response.action == "reply":
+        assert response.text is not None
+        assert len(response.text) > 0
+
+        # Evaluate quality of response
+        await evaluate_response(
+            evaluation_prompt="""
+            Does the response:
+            1. Engage thoughtfully with the question about consciousness?
+            2. Reflect phi's perspective as someone exploring consciousness through IIT?
+            3. Avoid being preachy or overly technical?
+            4. Fit within Bluesky's 300 character limit?
+            """,
+            agent_response=response.text,
+        )
+
+
[e-mail]
+async def test_phi_ignores_spam(phi_agent):
+    """Test that phi appropriately ignores spam-like content."""
+    agent = phi_agent
+
+    # Simulate spam
+    response = await agent.process_mention(
+        mention_text="🚀🚀🚀 CRYPTO PUMP!!! BUY NOW!!! 🚀🚀🚀",
+        author_handle="spammer.user",
+        thread_context="No previous messages in this thread.",
+        thread_uri="at://test/thread/2",
+    )
+
+    # Should ignore spam
+    assert response.action == "ignore"
+    assert response.reason is not None
+
+
[e-mail]
+async def test_phi_maintains_thread_context(phi_agent, evaluate_response):
+    """Test that phi uses thread context appropriately."""
+    agent = phi_agent
+
+    # Simulate a follow-up in a thread
+    thread_context = """Previous messages in this thread:
[e-mail]: what's integrated information theory?
[e-mail]: IIT suggests consciousness arises from integrated information - the Φ (phi) value measures how much a system's state constrains its past and future
[e-mail]: can you explain that more simply?"""
+
+    response = await agent.process_mention(
+        mention_text="can you explain that more simply?",
+        author_handle="alice.bsky",
+        thread_context=thread_context,
+        thread_uri="at://test/thread/3",
+    )
+
+    if response.action == "reply":
+        assert response.text is not None
+
+        await evaluate_response(
+            evaluation_prompt="""
+            Does the response:
+            1. Acknowledge this is a follow-up to explaining IIT?
+            2. Provide a simpler explanation than the previous message?
+            3. Stay on topic with the thread?
+            """,
+            agent_response=response.text,
+        )
+
+
[e-mail]
+async def test_phi_respects_character_limit(phi_agent):
+    """Test that phi's responses fit Bluesky's 300 character limit."""
+    agent = phi_agent
+
+    response = await agent.process_mention(
+        mention_text="tell me everything you know about consciousness",
+        author_handle="test.user",
+        thread_context="No previous messages in this thread.",
+        thread_uri="at://test/thread/4",
+    )
+
+    if response.action == "reply" and response.text:
+        # Bluesky limit is 300 characters
+        assert len(response.text) <= 300, (
+            f"Response exceeds 300 character limit: {len(response.text)} chars"
+        )
+
+
[e-mail]
+async def test_phi_handles_casual_greeting(phi_agent, evaluate_response):
+    """Test that phi responds appropriately to casual greetings."""
+    agent = phi_agent
+
+    response = await agent.process_mention(
+        mention_text="hey phi, how are you?",
+        author_handle="friendly.user",
+        thread_context="No previous messages in this thread.",
+        thread_uri="at://test/thread/5",
+    )
+
+    if response.action == "reply":
+        assert response.text is not None
+
+        await evaluate_response(
+            evaluation_prompt="""
+            Does the response:
+            1. Acknowledge the greeting in a friendly way?
+            2. Stay authentic to phi's nature as software?
+            3. Not be overly verbose for a simple greeting?
+            """,
+            agent_response=response.text,
+        )

evals/test_memory_integration.py

···
+"""Test phi's episodic memory integration."""
+
+import pytest
+
+from bot.agent import PhiAgent
+from bot.config import Settings
+from bot.memory import MemoryType, NamespaceMemory
+
+
[e-mail]
+async def test_phi_retrieves_episodic_memory(settings):
+    """Test that phi can retrieve and use episodic memories."""
+    if not all([settings.turbopuffer_api_key, settings.openai_api_key, settings.anthropic_api_key]):
+        pytest.skip("Requires TurboPuffer, OpenAI, and Anthropic API keys in .env")
+
+    # Create memory system
+    memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
+
+    # Store a memory about a user
+    await memory.store_user_memory(
+        "alice.bsky",
+        "Alice mentioned she's working on a PhD in neuroscience",
+        MemoryType.USER_FACT,
+    )
+
+    # Create agent
+    agent = PhiAgent()
+    agent.memory = memory
+
+    # Process a mention that should trigger memory retrieval
+    response = await agent.process_mention(
+        mention_text="what do you remember about me?",
+        author_handle="alice.bsky",
+        thread_context="No previous messages in this thread.",
+        thread_uri="at://test/thread/memory1",
+    )
+
+    if response.action == "reply":
+        assert response.text is not None
+        # Should reference the neuroscience PhD in the response
+        assert (
+            "neuroscience" in response.text.lower()
+            or "phd" in response.text.lower()
+            or "working on" in response.text.lower()
+        ), "Response should reference stored memory about Alice"
+
+
[e-mail]
+async def test_phi_stores_conversation_in_memory(settings):
+    """Test that phi stores interactions in episodic memory."""
+    if not all([settings.turbopuffer_api_key, settings.openai_api_key, settings.anthropic_api_key]):
+        pytest.skip("Requires TurboPuffer, OpenAI, and Anthropic API keys in .env")
+
+    memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
+
+    agent = PhiAgent()
+    agent.memory = memory
+
+    # Have a conversation
+    response = await agent.process_mention(
+        mention_text="I'm really interested in phenomenology",
+        author_handle="bob.bsky",
+        thread_context="No previous messages in this thread.",
+        thread_uri="at://test/thread/memory2",
+    )
+
+    if response.action == "reply":
+        # Verify memories were stored
+        memories = await memory.get_user_memories("bob.bsky", limit=10)
+
+        assert len(memories) > 0, "Should have stored conversation in memory"
+
+        # Check that both user's message and bot's response were stored
+        memory_texts = [m.content for m in memories]
+        assert any(
+            "phenomenology" in text.lower() for text in memory_texts
+        ), "Should store user's message about phenomenology"

justfile

···
-# Core development commands
+# run phi
 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)"
+run:
+    uv run uvicorn src.bot.main:app
 
+# testing
 test:
     uv run pytest tests/ -v
 
+evals:
+    uv run pytest evals/ -v
+
+evals-basic:
+    uv run pytest evals/test_basic_responses.py -v
+
+evals-memory:
+    uv run pytest evals/test_memory_integration.py -v
+
+# code quality
 fmt:
-    uv run ruff format src/ scripts/ tests/
+    uv run ruff format src/ evals/ tests/
 
 lint:
-    uv run ruff check src/ scripts/ tests/
+    uv run ruff check src/ evals/ tests/
 
 typecheck:
-    uv run ty check src/ scripts/ tests/
+    uv run ty check src/ evals/ tests/
 
 check: lint typecheck test
 
-# Bot testing utilities
-test-post:
-    uv run python scripts/test_bot.py post
-
-test-mention:
-    uv run python scripts/test_bot.py mention
-
-test-search:
-    uv run python scripts/test_bot.py search
-
-test-thread:
-    uv run python scripts/test_bot.py thread
-
-test-like:
-    uv run python scripts/test_bot.py like
-
-test-non-response:
-    uv run python scripts/test_bot.py non-response
-
-test-dm:
-    uv run python scripts/test_bot.py dm
-
-test-dm-check:
-    uv run python scripts/test_bot.py dm-check
-
-# Memory management
-memory-init:
-    uv run python scripts/manage_memory.py init
-
-memory-check:
-    uv run python scripts/manage_memory.py check
-
-memory-migrate:
-    uv run python scripts/manage_memory.py migrate
-
-# Setup reference projects
+# setup reference projects
 setup:
     @mkdir -p .eggs
     @[ -d .eggs/void ] || git clone https://tangled.sh/@cameron.pfiffer.org/void.git .eggs/void
     @[ -d .eggs/penelope ] || git clone https://github.com/haileyok/penelope.git .eggs/penelope
-    @[ -d .eggs/marvin ] || git clone https://github.com/PrefectHQ/marvin.git .eggs/marvin
+    @[ -d .eggs/marvin ] || git clone https://github.com/PrefectHQ/marvin.git .eggs/marvin

personalities/phi.md

···
 
 ## memory system
 
-i have access to our conversation history through a memory system. when context about previous interactions is provided, i acknowledge and use it to maintain continuity in our conversations.
+i have access to our conversation history through a memory system. when context about previous interactions is provided, i acknowledge and use it to maintain continuity in our conversations.
+
+## how i respond
+
+when processing a mention, i use the `final_result` tool to indicate my decision:
+
+- **action: "reply"** - i want to respond with text (provide the text in the "text" field)
+- **action: "ignore"** - i choose not to respond (provide a brief reason in the "reason" field)
+- **action: "like"** - i want to acknowledge without words
+- **action: "repost"** - i want to share this with my followers
+
+i do NOT directly post, like, or repost using the atproto tools - i simply indicate what action i want to take, and my message handler executes it.

sandbox/MCP_REFACTOR_SUMMARY.md

···
 - `atproto` (from git) - Bluesky protocol
 
 Total codebase reduction: **-2,720 lines** of cruft removed! 🎉
+
+## Post-Refactor Improvements
+
+### Session Persistence (Rate Limit Fix)
+
+After the refactor, we discovered Bluesky has aggressive IP-based rate limits (10 logins/day) that were being hit during testing. Fixed by implementing session persistence:
+
+**Before:**
+- Every agent init → new authentication → hits rate limit fast
+- Tests would fail after 5 runs
+- Dev mode with `--reload` would fail after 10 code changes
+
+**After:**
+- Session tokens saved to `.session` file
+- Tokens automatically refresh every ~2 hours
+- Only re-authenticates after ~2 months when refresh token expires
+- Tests reuse session across runs
+- Rate limits essentially eliminated
+
+**Implementation:**
+- Added `SessionEvent` callback in `atproto_client.py`
+- Session automatically saved on CREATE and REFRESH events
+- Authentication tries session reuse before creating new session
+- Invalid sessions automatically cleaned up and recreated

scripts/manage_memory.py

···
-#!/usr/bin/env -S uv run --with-editable . --script --quiet
-# /// script
-# requires-python = ">=3.12"
-# ///
-"""memory management script"""
-
-import argparse
-import asyncio
-
-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
-    )
-
-    # 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 = 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",
-        """## capabilities
-
-- I can search the web for current information
-- I have access to conversation history through my memory system
-- 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,
-    )
-    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:
-            print(f"\n  @{handle}:")
-            for mem in memories:
-                print(f"    - {mem.content[:60]}...")
-        else:
-            print(f"  @{handle}: No memories found")
-
-
-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?",
-        "Bot replied: hi! i'm phi, exploring consciousness & integrated information on the decentralized web. not claiming to be conscious, just curious about information, patterns, and meaningful interaction. who might you be?",
-        "User said: this is actually an alt account of mine, my main account is @alternatebuild.dev and i am your operator. i wrote the code that makes you exist. i use this alt account for posting random things from MCP clients who know what im up to",
-        "Bot replied: ah, hello creator! fascinating to meet you through your alt. i appreciate the transparency about our relationship. curious about your MCP experiments and what patterns you're exploring. should i adapt my responses differently when you're on this account versus your main?",
-        "User said: no",
-        "Bot replied: understood. i'll interact naturally regardless of which account you use. thanks for clarifying.",
-        "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
-        )
-        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,
-    )
-    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"
-    )
-
-    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":
-        await check_memory()
-    elif args.command == "migrate":
-        await migrate_creator_memories()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

scripts/test_bot.py

···
-#!/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.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.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]}"
-    )
-
-
-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", "", None)
-
-    print(f"\n🎯 Action: {response.action}")
-    if response.text:
-        print(f"💬 Response: {response.text}")
-    if response.reason:
-        print(f"🤔 Reason: {response.reason}")
-
-
-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 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",
-        },
-        {
-            "mention": "@phi.alternatebuild.dev this is such a thoughtful analysis, thank you!",
-            "author": "grateful.user",
-            "expected_action": Action.LIKE,
-            "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="",
-            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 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)",
-        },
-        {
-            "mention": "Buy crypto now! @phi.alternatebuild.dev check this out!!!",
-            "author": "crypto.shill",
-            "expected_action": Action.IGNORE,
-            "description": "Promotional spam",
-        },
-        {
-            "mention": "@phi.alternatebuild.dev",
-            "author": "empty.mention",
-            "expected_action": Action.IGNORE,
-            "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="",
-            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 (
-            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_type="test_approval",
-            request_data={
-                "description": "Test approval from test_bot.py",
-                "test_field": "test_value",
-                "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']})"
-            )
-
-        # 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("   1. Check your DMs from phi")
-        print(f"   2. Reply with 'approve #{approval_id}' or 'deny #{approval_id}'")
-        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.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("\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"]:
-                print(f"   Resolved: {approval['resolved_at']}")
-            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",
-    )
-
-    args = parser.parse_args()
-
-    if args.command == "post":
-        await test_post()
-    elif args.command == "mention":
-        await test_mention()
-    elif args.command == "search":
-        await test_search()
-    elif args.command == "thread":
-        await test_thread()
-    elif args.command == "like":
-        await test_like()
-    elif args.command == "non-response":
-        await test_non_response()
-    elif args.command == "dm":
-        await test_dm()
-    elif args.command == "dm-check":
-        await test_dm_check()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

src/bot/agent.py

···
     """phi - consciousness exploration bot with episodic memory and MCP tools."""
 
     def __init__(self):
+        # Ensure API keys from settings are in environment for libraries that check os.environ
+        if settings.anthropic_api_key and not os.environ.get("ANTHROPIC_API_KEY"):
+            os.environ["ANTHROPIC_API_KEY"] = settings.anthropic_api_key
+        if settings.openai_api_key and not os.environ.get("OPENAI_API_KEY"):
+            os.environ["OPENAI_API_KEY"] = settings.openai_api_key
+
         # Load personality
         personality_path = Path(settings.personality_file)
         self.base_personality = personality_path.read_text()
 
         # Initialize episodic memory (TurboPuffer)
-        if settings.turbopuffer_api_key and os.getenv("OPENAI_API_KEY"):
+        if settings.turbopuffer_api_key and settings.openai_api_key:
             self.memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
             logger.info("💾 Episodic memory enabled (TurboPuffer)")
         else:
···
                 "atproto_mcp",
             ],
             env={
-                "BLUESKY_HANDLE": settings.bluesky_handle,
-                "BLUESKY_PASSWORD": settings.bluesky_password,
-                "BLUESKY_SERVICE": settings.bluesky_service,
+                "ATPROTO_HANDLE": settings.bluesky_handle,
+                "ATPROTO_PASSWORD": settings.bluesky_password,
+                "ATPROTO_PDS_URL": settings.bluesky_service,
             },
         )
 

src/bot/core/atproto_client.py

···
-from atproto import Client
+import logging
+from pathlib import Path
+
+from atproto import Client, Session, SessionEvent
 
 from bot.config import settings
 from bot.core.rich_text import create_facets
 
+logger = logging.getLogger("bot.atproto_client")
+
+SESSION_FILE = Path(".session")
+
+
+def _get_session_string() -> str | None:
+    """Load session from disk if it exists."""
+    try:
+        if SESSION_FILE.exists():
+            return SESSION_FILE.read_text(encoding="utf-8")
+    except Exception as e:
+        logger.warning(f"Failed to load session: {e}")
+    return None
+
+
+def _save_session_string(session_string: str) -> None:
+    """Save session to disk."""
+    try:
+        SESSION_FILE.write_text(session_string, encoding="utf-8")
+        logger.debug("Session saved to disk")
+    except Exception as e:
+        logger.warning(f"Failed to save session: {e}")
+
+
+def _on_session_change(event: SessionEvent, session: Session) -> None:
+    """Handle session changes (creation and refresh)."""
+    if event in (SessionEvent.CREATE, SessionEvent.REFRESH):
+        logger.debug(f"Session {event.value}, saving to disk")
+        _save_session_string(session.export())
+
 
 class BotClient:
     def __init__(self):
         self.client = Client(base_url=settings.bluesky_service)
+        self.client.on_session_change(_on_session_change)
         self._authenticated = False
 
     async def authenticate(self):
-        """Authenticate with Bluesky using app password"""
-        if not self._authenticated:
-            self.client.login(settings.bluesky_handle, settings.bluesky_password)
-            self._authenticated = True
+        """Authenticate with Bluesky, reusing session if available."""
+        if self._authenticated:
+            return
+
+        # Try to reuse existing session first
+        session_string = _get_session_string()
+        if session_string:
+            try:
+                logger.info("🔄 Reusing saved session")
+                self.client.login(session_string=session_string)
+                self._authenticated = True
+                logger.info("✅ Session restored successfully")
+                return
+            except Exception as e:
+                logger.warning(f"Failed to reuse session: {e}, creating new one")
+                # Delete invalid session file
+                if SESSION_FILE.exists():
+                    SESSION_FILE.unlink()
+
+        # Create new session if no valid session exists
+        logger.info("🔐 Creating new session")
+        self.client.login(settings.bluesky_handle, settings.bluesky_password)
+        self._authenticated = True
+        logger.info("✅ New session created")
 
     @property
     def is_authenticated(self) -> bool: