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/responses/router.py

@@ -10,7 +10,6 @@ from sse_starlette.sse import EventSourceResponse
 from src.responses import service
 from src.responses.schemas import ResponseRequest, Response
 from src.core.exceptions import ModelNotFoundError, AppException
-from src.core.context import current_user, current_conversation, get_default_user
 from src.core.logging_config import get_logger
 
 logger = get_logger(__name__)
@@ -37,77 +36,16 @@ async def create_response(
 
     Returns:
         Response object or SSE stream
-
-    Example non-streaming request:
-        POST /v1/responses
-        {
-            "model": "lorem-tester",
-            "input": [{"role": "user", "content": "Hello"}],
-            "reasoning": {"effort": "medium", "summary": "auto"},
-            "stream": false
-        }
-
-    Example streaming request:
-        POST /v1/responses
-        {
-            "model": "lorem-tester",
-            "input": [{"role": "user", "content": "Hello"}],
-            "stream": true
-        }
-
-    Response format (non-streaming):
-        {
-            "id": "resp_...",
-            "object": "response",
-            "created_at": 1733529600,
-            "model": "lorem-tester",
-            "status": "completed",
-            "output": [
-                {
-                    "type": "reasoning",
-                    "id": "rs_...",
-                    "summary": ["Analyzing...", "Considering..."]
-                },
-                {
-                    "type": "message",
-                    "id": "msg_...",
-                    "role": "assistant",
-                    "content": [{"type": "output_text", "text": "Lorem ipsum..."}]
-                }
-            ],
-            "usage": {
-                "input_tokens": 10,
-                "output_tokens": 50,
-                "reasoning_tokens": 20,
-                "total_tokens": 80
-            }
-        }
-
-    Streaming format (SSE):
-        event: response.reasoning_summary_text.delta
-        data: {"delta": "Analyzing..."}
-
-        event: response.output_text.delta
-        data: {"delta": "Lorem"}
-
-        event: response.done
-        data: {"response": {...}}
     """
-    # Set request context (propagates through all async calls)
-    effective_user = request.user or get_default_user()
-    user_token = current_user.set(effective_user)
-    conv_id = request.metadata.get("conversation_id") if request.metadata else None
-    conv_token = current_conversation.set(conv_id)
-
     logger.info(
         "response_request_received",
         model=request.model,
-        user=effective_user,
-        conversation_id=conv_id,
+        user=request.user,
+        streaming=request.stream,
     )
 
     try:
-        # Check if this is a Tatlock request - use Steward preprocessing (Phase 2)
+        # Check if this is a Tatlock request - use Steward preprocessing
         model_id = request.model
         if "." in model_id:
             model_id = model_id.split(".", 1)[1]
@@ -116,21 +54,20 @@ async def create_response(
 
         if request.stream:
             logger.info("Streaming response requested")
+
             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)
                 )
 
-        # Use appropriate service method
+        # Non-streaming response
         if use_steward:
             logger.info("Using Steward preprocessing for Tatlock request")
             return await service.create_response_with_steward(request)
@@ -148,8 +85,3 @@ async def create_response(
     except Exception as e:
         logger.error(f"Unexpected error: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail="Internal server error")
-
-    finally:
-        # Reset context (important for connection reuse)
-        current_user.reset(user_token)
-        current_conversation.reset(conv_token)