feat: add Claude backend with automatic Ollama fallback (Claudification Phase 1)

All agents now prefer Claude API when ANTHROPIC_API_KEY is configured,
with automatic fallback to Ollama when offline or unconfigured. New
src/anthropic/ module provides model selection via get_model() factory.

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

src/agents/steward/agent.py

@@ -5,11 +5,13 @@ The Steward analyzes incoming requests, identifies relevant household
 capabilities, and provides focused recommendations to Tatlock (the Butler).
 This creates a two-tier architecture that prevents cognitive overload.
 
-Uses plain text output (not JSON) for reliability with Ollama models.
+Uses plain text output (not JSON) for reliability. Supports both Claude
+(preferred) and Ollama (fallback) backends via direct API calls.
 """
 import httpx
 from typing import Optional
 
+from src.anthropic.model_selector import is_claude_available, get_model_info
 from src.core.config import config
 from src.core.household_registry import get_household_registry
 from src.core.logging_config import get_logger
@@ -105,22 +107,74 @@ class StewardAgent:
     Analyzes requests with full conversation context and recommends
     which household capabilities the Butler should use.
 
-    Uses plain text output for reliability with Ollama models.
+    Uses plain text output for reliability. Supports both Claude
+    (preferred) and Ollama (fallback) backends via direct API calls.
     """
 
     def __init__(self):
-        """Initialize Steward with Ollama model (same as Tatlock for VRAM efficiency)."""
+        """Initialize Steward with backend selection based on availability."""
+        # Ollama config (fallback)
         self.ollama_host = str(config.OLLAMA_HOST).rstrip('/')
-        self.model_name = config.OLLAMA_DEFAULT_MODEL
+        self.ollama_model = config.OLLAMA_DEFAULT_MODEL
+
+        # Claude config (preferred)
+        self.claude_model = config.ANTHROPIC_MODEL
+        self._anthropic_client = None
+
+        # Determine which backend to use
+        self._use_claude = config.PREFER_CLOUD_BACKEND and is_claude_available()
+
         self.timeout = 30.0  # 30 second timeout for analysis
 
+        model_info = get_model_info()
         logger.info(
             "steward_agent_created",
-            ollama_host=self.ollama_host,
-            model=self.model_name,
+            backend=model_info["backend"],
+            model=model_info["model"],
             timeout=self.timeout,
         )
 
+    def _get_anthropic_client(self):
+        """Get or create Anthropic client (lazy initialization)."""
+        if self._anthropic_client is None:
+            from anthropic import AsyncAnthropic
+            self._anthropic_client = AsyncAnthropic(api_key=config.ANTHROPIC_API_KEY)
+        return self._anthropic_client
+
+    async def _call_claude(self, system_prompt: str, user_message: str) -> str:
+        """Call Claude API directly for plain text generation."""
+        client = self._get_anthropic_client()
+
+        response = await client.messages.create(
+            model=self.claude_model,
+            max_tokens=1024,
+            system=system_prompt,
+            messages=[{"role": "user", "content": user_message}],
+            temperature=0.3,  # Lower = more consistent
+        )
+
+        return response.content[0].text.strip()
+
+    async def _call_ollama(self, prompt: str) -> str:
+        """Call Ollama API directly for plain text generation."""
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.post(
+                f"{self.ollama_host}/api/generate",
+                json={
+                    "model": self.ollama_model,
+                    "prompt": prompt,
+                    "stream": False,
+                    "options": {
+                        "temperature": 0.3,  # Lower = more consistent
+                        "top_p": 0.9
+                    }
+                }
+            )
+
+            response.raise_for_status()
+            result = response.json()
+            return result["response"].strip()
+
     async def analyze(
         self,
         query: str,
@@ -129,6 +183,8 @@ class StewardAgent:
         """
         Analyze query and return plain text recommendation.
 
+        Uses Claude if available, falls back to Ollama.
+
         Args:
             query: User's query to analyze
             conversation_history: Previous conversation turns
@@ -144,35 +200,48 @@ class StewardAgent:
         history = conversation_history or []
         prompt = build_steward_prompt(query, history)
 
-        logger.debug("steward_calling_ollama", query_preview=query[:100])
+        backend = "claude" if self._use_claude else "ollama"
+        logger.debug(
+            "steward_calling_llm",
+            backend=backend,
+            query_preview=query[:100],
+        )
 
-        # Call Ollama API directly (more reliable than PydanticAI for plain text)
-        async with httpx.AsyncClient(timeout=self.timeout) as client:
-            response = await client.post(
-                f"{self.ollama_host}/api/generate",
-                json={
-                    "model": self.model_name,
-                    "prompt": prompt,
-                    "stream": False,
-                    "options": {
-                        "temperature": 0.3,  # Lower = more consistent
-                        "top_p": 0.9
-                    }
-                }
-            )
-
-            response.raise_for_status()
-            result = response.json()
-
-            analysis_text = result["response"].strip()
+        try:
+            if self._use_claude:
+                # For Claude, split into system + user message
+                # The prompt contains both, but Claude prefers explicit system
+                analysis_text = await self._call_claude(
+                    system_prompt="You are the Steward of the household, advising the Butler (Tatlock) on which capabilities to use. Be concise and specific.",
+                    user_message=prompt,
+                )
+            else:
+                analysis_text = await self._call_ollama(prompt)
 
             logger.debug(
                 "steward_analysis_received",
-                text_preview=analysis_text[:150]
+                backend=backend,
+                text_preview=analysis_text[:150],
             )
 
             return analysis_text
 
+        except Exception as e:
+            # If Claude fails, try Ollama as fallback
+            if self._use_claude:
+                logger.warning(
+                    "steward_claude_fallback",
+                    error=str(e),
+                )
+                analysis_text = await self._call_ollama(prompt)
+                logger.debug(
+                    "steward_analysis_received",
+                    backend="ollama_fallback",
+                    text_preview=analysis_text[:150],
+                )
+                return analysis_text
+            raise
+
 
 # Global Steward instance
 _steward_agent = None