feat(agents): enforce one librarian timeout budget

- add LIBRARIAN_TIMEOUT config (default 180s) and enforce it with
  asyncio.wait_for inside delegate_to_librarian, covering the live
  paths (steward direct delegation and SSE streaming) that had no cap
- timeouts fail honestly: success=False with a curated butler sentence,
  detail in logs
- set an explicit timeout on TatlockOllamaProvider's AsyncOpenAI client
  from OLLAMA_TIMEOUT instead of the SDK default (~600s per LLM call)
- remove the contradictory unused 60s default from
  AgentRequest.timeout_seconds; coordination falls back to the
  configured budget

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/agents/delegation.py

@@ -8,10 +8,12 @@ returns a structured result for synthesis.
 This implements the agent-as-tool pattern recommended by PydanticAI:
 agents call other agents via tool wrappers, keeping each agent focused.
 """
+import asyncio
 from collections.abc import AsyncGenerator
 from dataclasses import dataclass, field
 from enum import Enum
 
+from src.core.config import config
 from src.core.logging_config import get_logger
 from src.core.tracing import SpanType, trace_span
 
@@ -252,8 +254,14 @@ async def delegate_to_librarian(
         },
     ) as span:
         try:
-            # Use run() not run_stream() - avoids Ollama bug
-            output = await run_librarian(task=task, context=context)
+            # Use run() not run_stream() - avoids Ollama bug.
+            # One timeout budget for the whole delegation - covers both
+            # live paths (steward direct delegation and streaming), which
+            # previously had no cap at all (SDK default ~600s per LLM call).
+            output = await asyncio.wait_for(
+                run_librarian(task=task, context=context),
+                timeout=config.LIBRARIAN_TIMEOUT,
+            )
 
             logger.info(
                 "delegation_to_librarian_completed",
@@ -275,6 +283,30 @@ async def delegate_to_librarian(
                 output=output,
             )
 
+        except TimeoutError:
+            logger.error(
+                "delegation_to_librarian_timeout",
+                task=task[:50],
+                timeout_seconds=config.LIBRARIAN_TIMEOUT,
+            )
+
+            if span:
+                span.metadata["success"] = False
+                span.details["error"] = (
+                    f"timed out after {config.LIBRARIAN_TIMEOUT}s"
+                )
+
+            return DelegationResult(
+                expert_name="librarian",
+                task=task,
+                success=False,
+                output=(
+                    "I'm afraid the research took longer than expected "
+                    "and had to be abandoned, sir."
+                ),
+                error="The Librarian did not respond within the time budget.",
+            )
+
         except Exception as e:
             logger.error(
                 "delegation_to_librarian_error",