feat: implement Phase 2 two-tier architecture with Steward

Add comprehensive two-tier architecture where Steward analyzes requests
and Tatlock executes with scoped tools. Includes full infrastructure for
request preprocessing, tool tracking, benchmarking, and streaming.

**Added:**
- Steward agent for request analysis and capability recommendation
- Household Registry for centralized capability management
- Request preprocessing pipeline (Steward → Tatlock flow)
- Tool usage tracking and benchmarking system
- Streaming transparency (Steward reasoning visible in streams)
- Structured logging with operation timing
- Redis benchmark storage with 30-day expiry
- Benchmark analysis CLI tools

**Infrastructure:**
- src/agents/steward/ - Steward agent implementation
- src/agents/tatlock_core/ - Tatlock capability domain
- src/core/preprocessing.py - Request preprocessing pipeline
- src/core/tool_tracking.py - Tool call tracking
- src/core/benchmarks.py - Benchmark recording system
- src/core/household_registry.py - Capability registry
- src/core/startup.py - Application startup coordination
- src/core/logging_config.py - Structured logging setup

**Integration:**
- Responses API uses Steward for Tatlock requests
- Chat Completions wraps Responses API for OpenAI compatibility
- Streaming coordinator supports Steward + Tatlock flow
- Tool scoping per request based on Steward recommendations

**Testing:**
- Integration tests for Steward-Tatlock flow
- Benchmark and registry unit tests
- Steward streaming tests

See PHASE2_PLAN.md and PHASE2_COMPLETE.md for detailed documentation.

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

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

src/responses/router.py

@@ -95,13 +95,35 @@ async def create_response(
     logger.info(f"Response request for model: {request.model}")
 
     try:
+        # Check if this is a Tatlock request - use Steward preprocessing (Phase 2)
+        model_id = request.model
+        if "." in model_id:
+            model_id = model_id.split(".", 1)[1]
+
+        use_steward = model_id.lower() == "tatlock"
+
         if request.stream:
             logger.info("Streaming response requested")
-            return EventSourceResponse(
-                service.create_response_stream(request)
-            )
+            if use_steward:
+                logger.info("Streaming with Steward preprocessing for Tatlock request")
+                # Use Steward + Tatlock streaming (Milestone 3.5)
+                from src.responses.streaming import StreamingCoordinator
+                coordinator = StreamingCoordinator()
+                return EventSourceResponse(
+                    coordinator.stream_response_with_steward(request)
+                )
+            else:
+                # Regular streaming for non-Tatlock models
+                return EventSourceResponse(
+                    service.create_response_stream(request)
+                )
 
-        return await service.create_response(request)
+        # Use appropriate service method
+        if use_steward:
+            logger.info("Using Steward preprocessing for Tatlock request")
+            return await service.create_response_with_steward(request)
+        else:
+            return await service.create_response(request)
 
     except ModelNotFoundError as e:
         logger.error(f"Model not found: {e}")

src/responses/service.py

@@ -3,6 +3,7 @@ Response service for creating responses.
 
 Handles both streaming and non-streaming response generation.
 Tracks conversation history for analytics and future vector memory.
+Integrates with Steward preprocessing for Phase 2 two-tier architecture.
 """
 
 import time
@@ -22,6 +23,11 @@ from src.responses.schemas import (
 from src.responses.streaming import StreamingCoordinator
 from src.responses.history import ConversationHistory
 from src.responses.context import ContextWindow
+from src.core.preprocessing import preprocess_request
+from src.core.tool_tracking import ToolCallTracker
+from src.core.logging_config import get_logger
+
+logger = get_logger(__name__)
 
 # Global conversation history tracker
 # In production, this would be backed by a database or Redis
@@ -59,8 +65,18 @@ def _calculate_usage(input_messages: list[dict], output_items: list) -> Response
     reasoning_tokens = 0
 
     for item in output_items:
-        if hasattr(item, 'type'):
-            # Agent OutputItem objects
+        # Check if it's a schema object (has summary/content attributes directly)
+        if isinstance(item, ReasoningOutputItem):
+            reasoning_text = " ".join(item.summary)
+            reasoning_tokens += len(reasoning_text) // 4
+        elif isinstance(item, MessageOutputItem):
+            message_text = item.content[0].text
+            output_tokens += len(message_text) // 4
+        elif isinstance(item, FunctionCallOutputItem):
+            func_text = item.arguments
+            output_tokens += len(func_text) // 4
+        elif hasattr(item, 'type'):
+            # Agent OutputItem objects (backward compatibility)
             if item.type == "reasoning":
                 reasoning_text = " ".join(item.data.get("summary", []))
                 reasoning_tokens += len(reasoning_text) // 4
@@ -70,17 +86,6 @@ def _calculate_usage(input_messages: list[dict], output_items: list) -> Response
             elif item.type == "function_call":
                 func_text = item.data["arguments"]
                 output_tokens += len(func_text) // 4
-        else:
-            # Schema OutputItem objects
-            if isinstance(item, ReasoningOutputItem):
-                reasoning_text = " ".join(item.summary)
-                reasoning_tokens += len(reasoning_text) // 4
-            elif isinstance(item, MessageOutputItem):
-                message_text = item.content[0].text
-                output_tokens += len(message_text) // 4
-            elif isinstance(item, FunctionCallOutputItem):
-                func_text = item.arguments
-                output_tokens += len(func_text) // 4
 
     total_tokens = input_tokens + output_tokens + reasoning_tokens
 
@@ -157,6 +162,127 @@ async def create_response(request: ResponseRequest) -> Response:
     return response
 
 
+async def create_response_with_steward(request: ResponseRequest) -> Response:
+    """
+    Create response using Steward preprocessing (Phase 2 flow).
+
+    This is the two-tier architecture where:
+    1. Steward analyzes the request and recommends capabilities
+    2. Tatlock runs with scoped tools based on recommendations
+    3. Tool usage is tracked for benchmarking
+
+    Args:
+        request: Response request
+
+    Returns:
+        Response: Complete response object with Steward analysis included
+
+    Example:
+        request = ResponseRequest(
+            model="tatlock",
+            input=[{"role": "user", "content": "What's sqrt(144)?"}],
+            metadata={"conversation_id": "conv_abc123"}
+        )
+        response = await create_response_with_steward(request)
+    """
+    # Get or generate conversation ID
+    conversation_id = await _conversation_history.get_conversation_id(request)
+
+    # Extract user message and conversation history
+    user_message = ""
+    for msg in reversed(request.input):
+        if msg.get("role") == "user":
+            user_message = msg.get("content", "")
+            break
+
+    # Conversation history is all messages except the current one
+    conversation_history = request.input[:-1] if len(request.input) > 1 else []
+
+    logger.info(
+        "creating_response_with_steward",
+        user_message_preview=user_message[:100],
+        history_length=len(conversation_history),
+        conversation_id=conversation_id,
+    )
+
+    # Phase 1: Steward preprocessing
+    enriched = await preprocess_request(
+        user_message,
+        conversation_history=conversation_history,
+        conversation_id=conversation_id,
+    )
+
+    # Phase 2: Initialize tool tracker
+    tracker = ToolCallTracker(
+        recommended_capabilities=enriched.recommendation.recommended_capabilities,
+        conversation_id=conversation_id,
+    )
+
+    # Phase 3: Run Tatlock with scoped tools
+    from src.agents.tatlock import TatlockAgent
+    tatlock = TatlockAgent()
+
+    tatlock_response = await tatlock.run_with_scoped_tools(
+        user_message=user_message,
+        steward_note=enriched.steward_note,
+        scoped_tools=enriched.scoped_tools,
+        message_history=conversation_history,
+        tool_tracker=tracker,
+    )
+
+    # Phase 4: Finalize tool tracking
+    await tracker.finalize()
+
+    # Build response output items
+    output_items = []
+
+    # Add Steward reasoning as a reasoning output item
+    output_items.append(ReasoningOutputItem(
+        id=f"reasoning_{generate_id()}",
+        summary=[
+            "🎩 Steward's Analysis:",
+            enriched.steward_reasoning,
+        ],
+        status="completed"
+    ))
+
+    # Add Tatlock's message
+    output_items.append(MessageOutputItem(
+        id=f"msg_{generate_id()}",
+        role="assistant",
+        content=[OutputTextContent(
+            type="output_text",
+            text=tatlock_response,
+            annotations=[]
+        )],
+        status="completed"
+    ))
+
+    # Calculate usage (approximate)
+    usage = _calculate_usage(request.input, output_items)
+
+    response = Response(
+        id=f"resp_{generate_id()}",
+        created_at=int(time.time()),
+        model=request.model,
+        status="completed",
+        output=output_items,
+        usage=usage
+    )
+
+    # Track conversation history
+    await _conversation_history.add_response(conversation_id, response)
+
+    logger.info(
+        "response_with_steward_complete",
+        response_id=response.id,
+        recommended_capabilities=enriched.recommendation.recommended_capabilities,
+        tool_summary=tracker.get_summary(),
+    )
+
+    return response
+
+
 async def create_response_stream(
     request: ResponseRequest
 ) -> AsyncGenerator[dict, None]: