feat: integrate tracing throughout request pipeline

Instrument the full request flow with trace spans for debugging:

- Wrap expert delegations (librarian/biographer/housekeeper) in spans
- Add orchestrate and synthesize spans to TatlockAgent
- Trace Steward analysis in preprocessing
- Start/end traces in response service with context management
- Simplify router by moving context handling to service layer
- Include tracing router in debug mode
- Remove benchmark recording from tool_tracking and steward service

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

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

src/core/preprocessing.py

@@ -11,6 +11,7 @@ from src.agents.steward import analyze_request, format_steward_note
 from src.agents.steward.schemas import StewardRecommendation
 from src.core.household_registry import get_household_registry
 from src.core.logging_config import get_logger
+from src.core.tracing import trace_span, SpanType
 
 logger = get_logger(__name__)
 
@@ -93,12 +94,32 @@ async def preprocess_request(
         conversation_id=conversation_id,
     )
 
-    # Call Steward with full conversation history
-    recommendation = await analyze_request(
-        enriched_request,
-        conversation_history=conversation_history,
-        conversation_id=conversation_id,
-    )
+    # Call Steward with full conversation history (traced)
+    async with trace_span(
+        "steward_analysis",
+        SpanType.STEWARD,
+        metadata={
+            "request_preview": user_request[:100],
+            "history_length": len(conversation_history),
+        },
+    ) as span:
+        recommendation = await analyze_request(
+            enriched_request,
+            conversation_history=conversation_history,
+            conversation_id=conversation_id,
+        )
+
+        # Update span with results
+        if span:
+            span.metadata.update({
+                "recommended_capabilities": recommendation.recommended_capabilities,
+                "complexity": recommendation.estimated_complexity,
+                "has_memory_context": bool(recommendation.memory_context),
+                "has_conversation_context": recommendation.conversation_context.has_previous_context,
+            })
+            span.details["reasoning"] = recommendation.reasoning
+            if recommendation.enriched_query:
+                span.details["enriched_query"] = recommendation.enriched_query
 
     # Format note for Tatlock (includes conversation context)
     steward_note = await format_steward_note(recommendation)

src/core/tool_tracking.py

@@ -1,13 +1,11 @@
 """
-Tool call tracking and benchmarking.
+Tool call tracking.
 
 Tracks which tools are recommended by the Steward versus which tools
-are actually used by Tatlock, recording benchmarks for analysis.
+are actually used by Tatlock for debugging and analysis.
 """
-from datetime import datetime, timezone
 from typing import Optional
 
-from src.core.benchmarks import PerformanceBenchmark, get_benchmark_store
 from src.core.logging_config import get_logger
 
 logger = get_logger(__name__)
@@ -15,7 +13,7 @@ logger = get_logger(__name__)
 
 class ToolCallTracker:
     """
-    Tracks tool calls for benchmarking and accuracy analysis.
+    Tracks tool calls for accuracy analysis.
 
     Compares Steward's recommendations with Tatlock's actual tool usage
     to measure recommendation accuracy.
@@ -53,6 +51,10 @@ class ToolCallTracker:
             return tool_name.replace("delegate_to_", "")
         return tool_name
 
+    def log_call(self, message: str):
+        """Log a tool call message (for UI display)."""
+        logger.debug("tool_call_message", message=message)
+
     async def track_call(self, tool_name: str, duration: float):
         """
         Record a tool call with timing.
@@ -78,23 +80,6 @@ class ToolCallTracker:
                 recommended=list(self.recommended_capabilities),
             )
 
-        # Record benchmark to Redis
-        benchmark = PerformanceBenchmark(
-            timestamp=datetime.now(timezone.utc),
-            operation="tool_call",
-            duration_seconds=duration,
-            success=True,  # If we got here, the call succeeded
-            tool_name=tool_name,
-            was_recommended=was_recommended,
-            was_actually_used=True,
-            conversation_id=self.conversation_id,
-            metadata={
-                "recommended_capabilities": list(self.recommended_capabilities),
-            },
-        )
-
-        await get_benchmark_store().record(benchmark)
-
         logger.debug(
             "tool_call_tracked",
             tool_name=tool_name,
@@ -124,24 +109,6 @@ class ToolCallTracker:
                 conversation_id=self.conversation_id,
             )
 
-            # Record benchmarks for unused recommendations
-            for tool_name in unused_tools:
-                benchmark = PerformanceBenchmark(
-                    timestamp=datetime.now(timezone.utc),
-                    operation="tool_call",
-                    duration_seconds=0.0,  # Not used
-                    success=True,
-                    tool_name=tool_name,
-                    was_recommended=True,
-                    was_actually_used=False,
-                    conversation_id=self.conversation_id,
-                    metadata={
-                        "recommended_capabilities": list(self.recommended_capabilities),
-                        "reason": "recommended_but_unused",
-                    },
-                )
-                await get_benchmark_store().record(benchmark)
-
         # Log summary
         total_calls = sum(len(durations) for durations in self.actual_calls.values())
         logger.info(