feat: add Phase F.2 - The Biographer (memory agent)

Add The Biographer household member for user memory management:

Memory Service (direct access layer):
- src/core/memory_service.py for fast, LLM-free lookups
- Profile, preference, and fact management
- Session context with Redis caching
- Steward integration via prefetch_context()

The Biographer Agent:
- src/agents/biographer/ package with PydanticAI agent
- Discreet chronicler personality for privacy
- Tools: recall_semantic, list_memories, store_insight,
  update_profile, update_preference, forget_memory
- Registered with Household Registry on startup

Steward Integration:
- Memory context pre-fetch during analysis
- Profile/preferences included in Butler note
- Keyword-based context determination

Also includes:
- delegate_to_biographer() wrapper
- 34 new tests (capability + memory service)
- Version bump to 1.2.0

Documentation cleanup:
- Removed obsolete PHASE2_COMPLETE.md, PHASE2_PLAN.md
- Removed docs/library-desk-requirements.md
- Moved ORCHESTRATION_SCENARIOS.md to project root

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/agents/steward/schemas.py

@@ -4,7 +4,7 @@ Steward agent schemas.
 Defines the structured output models for Steward's request analysis
 and capability recommendations.
 """
-from typing import Literal, Optional
+from typing import Any, Literal, Optional
 
 from pydantic import BaseModel, Field
 
@@ -56,6 +56,10 @@ class StewardRecommendation(BaseModel):
         default=None,
         description="Description of capabilities that would be helpful but aren't available"
     )
+    memory_context: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Pre-fetched user context from memory (profile, preferences)"
+    )
 
     def format_for_butler(self) -> str:
         """
@@ -88,6 +92,23 @@ class StewardRecommendation(BaseModel):
         if self.missing_capabilities:
             lines.append(f"⚠️  Missing: {self.missing_capabilities}")
 
+        # Memory context (user profile and preferences)
+        if self.memory_context:
+            profile = self.memory_context.get("profile", {})
+            preferences = self.memory_context.get("preferences", {})
+
+            if profile or preferences:
+                lines.append("-" * 40)
+                lines.append("User Context:")
+
+            if profile:
+                for key, value in profile.items():
+                    lines.append(f"  • {key}: {value}")
+
+            if preferences:
+                prefs_str = ", ".join(f"{k}={v}" for k, v in preferences.items())
+                lines.append(f"  • preferences: {prefs_str}")
+
         lines.append("=" * 40)
 
         return "\n".join(lines)

src/agents/steward/service.py

@@ -5,13 +5,15 @@ Provides high-level interface for request analysis with logging,
 benchmarking, and error handling.
 
 Parses plain text recommendations into structured data.
+Includes memory pre-fetch for user context injection.
 """
 import re
-from typing import Optional
+from typing import Any, Optional
 
 from src.core.benchmarks import PerformanceBenchmark, get_benchmark_store
 from src.core.household_registry import get_household_registry
 from src.core.logging_config import get_logger, log_operation
+from src.core.memory_service import memory_service
 from .agent import get_steward_agent
 from .schemas import ConversationContext, StewardRecommendation
 
@@ -147,6 +149,69 @@ def _extract_missing_capabilities(text: str) -> Optional[str]:
     return None
 
 
+async def _prefetch_memory_context(user_request: str) -> dict[str, Any]:
+    """
+    Pre-fetch user context that might be needed for this request.
+
+    This is the "direct access" layer - fast lookups without LLM overhead.
+    Uses simple keyword matching to determine what context to fetch.
+
+    Args:
+        user_request: The user's request text
+
+    Returns:
+        Dict with profile and/or preferences data
+
+    Example:
+        >>> ctx = await _prefetch_memory_context("What's the weather?")
+        >>> ctx
+        {"profile": {"location": "Amsterdam"}}
+    """
+    request_lower = user_request.lower()
+
+    # Determine what context might be needed based on keywords
+    profile_keys = []
+
+    # Location-related queries
+    if any(word in request_lower for word in [
+        "weather", "temperature", "forecast", "nearby", "local",
+        "directions", "distance", "map", "here"
+    ]):
+        profile_keys.append("location")
+
+    # Time-related queries
+    if any(word in request_lower for word in [
+        "time", "schedule", "meeting", "appointment", "reminder",
+        "alarm", "when", "today", "tomorrow"
+    ]):
+        profile_keys.append("timezone")
+
+    # Personal queries
+    if any(word in request_lower for word in [
+        "my name", "who am i", "about me"
+    ]):
+        profile_keys.append("name")
+
+    # Always fetch preferences if they might affect response format
+    include_preferences = any(word in request_lower for word in [
+        "temperature", "weather", "convert", "unit", "format",
+        "celsius", "fahrenheit", "metric", "imperial"
+    ])
+
+    try:
+        return await memory_service.prefetch_context(
+            include_profile=bool(profile_keys),
+            include_preferences=include_preferences,
+            profile_keys=profile_keys if profile_keys else None,
+        )
+    except Exception as e:
+        logger.warning(
+            "steward_prefetch_memory_failed",
+            error=str(e),
+        )
+        return {}
+
+
 async def analyze_request(
     user_request: str,
     conversation_history: list[dict],
@@ -186,6 +251,10 @@ async def analyze_request(
         }
     ) as log_ctx:
         try:
+            # Pre-fetch user context from memory (fast, no LLM)
+            memory_context = await _prefetch_memory_context(user_request)
+            log_ctx["memory_context_keys"] = list(memory_context.keys())
+
             # Get Steward agent
             steward = get_steward_agent()
 
@@ -193,6 +262,7 @@ async def analyze_request(
                 "steward_analyzing_request",
                 request=user_request,
                 history_turns=len(conversation_history),
+                memory_context=bool(memory_context),
             )
 
             # Get plain text analysis from Steward
@@ -212,7 +282,8 @@ async def analyze_request(
                 reasoning=analysis_text,
                 estimated_complexity=complexity,
                 conversation_context=context,
-                missing_capabilities=missing
+                missing_capabilities=missing,
+                memory_context=memory_context,
             )
 
             # Update log context with results