fix(p2): Resolve duplicate report content and first-turn timeout bugs (#123)

## Summary

Fixes two P2 bugs + addresses CodeRabbit review feedback:

**P2 Bug Fixes:**
- **Duplicate Report Content**: Stateful deduplication in `run()` loop via `_handle_final_event()`
- **First Turn Timeout**: Reduced `max_results_per_tool` 10→5, increased `advanced_timeout` 300→600s

**CodeRabbit Fixes:**
- Added missing `@patch` decorator + return type to timeout test
- Removed unreachable dead code from `_process_event()`
- Created P3 tech debt doc for Modal integration removal

All 318 tests pass.

docs/ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # DeepBoner Architecture
 
-> **Last Updated**: 2025-12-01
+> **Last Updated**: 2025-12-03
 
 ---
 
@@ -15,7 +15,7 @@
 │   NO (Free Tier)              YES (Paid Tier)               │
 │   ──────────────              ───────────────               │
 │   HuggingFace backend         OpenAI backend                │
-│   Qwen 2.5 72B (free)         GPT-5 (paid)                  │
+│   Qwen 2.5 7B (free)          GPT-5 (paid)                  │
 │                                                              │
 │   SAME orchestration logic for both                          │
 │   ONE codebase, different LLM backends                       │
@@ -28,12 +28,21 @@
 
 ## Current Status
 
-**Free Tier is BLOCKED** by upstream bug #2562.
+**Both tiers are WORKING** as of December 2025.
 
-Once [PR #2566](https://github.com/microsoft/agent-framework/pull/2566) merges:
-1. Update `agent-framework` dependency
-2. Free tier works
-3. Done
+- **Free Tier**: Uses Accumulator Pattern to bypass upstream repr bug
+- **Paid Tier**: Full OpenAI GPT-5 integration
+
+---
+
+## Key Fixes Applied
+
+| Issue | Fix | PR |
+|-------|-----|-----|
+| Tool execution failure | Removed premature `__function_invoking_chat_client__` marker | fix/P1-free-tier |
+| Repr garbage in output | Accumulator Pattern bypasses upstream bug | PR #117 |
+| 72B model routing failures | Switched to 7B (native HF infra) | PR #118 |
+| Evidence deduplication | Cross-source dedup by PMID/DOI | PR #122 |
 
 ---
 
@@ -65,7 +74,7 @@ def get_chat_client():
 | Condition | Backend | Model |
 |-----------|---------|-------|
 | User provides OpenAI key | OpenAI | GPT-5 |
-| No API key provided | HuggingFace | Qwen 2.5 72B (free) |
+| No API key provided | HuggingFace | Qwen 2.5 7B (free) |
 
 ---
 
@@ -87,16 +96,6 @@ def get_chat_client():
 
 ---
 
-## Upstream Blocker
-
-**Bug:** Microsoft Agent Framework produces `repr()` garbage for tool-call-only messages.
-
-**Fix:** [PR #2566](https://github.com/microsoft/agent-framework/pull/2566) - waiting to merge.
-
-**Tracking:** [Issue #2562](https://github.com/microsoft/agent-framework/issues/2562)
-
----
-
 ## References
 
 - [Pydantic AI](https://ai.pydantic.dev/) - Structured outputs framework

docs/architecture/HF_FREE_TIER_ANALYSIS.md

@@ -64,5 +64,50 @@ For the Unified Chat Client architecture:
 1.  **Tier 0 (Free):** Hardcoded to Native Models (Qwen 7B, Mistral Nemo).
 2.  **Tier 1 (BYO Key):** Allow user to select any model (70B+), assuming they provide a key that grants access to premium providers or PRO tier.
 
+---
+
+## 5. Known Content Quality Limitations (7B Models)
+
+**Status**: As of December 2025, the Free Tier (Qwen 2.5 7B) produces **working multi-agent orchestration** but with notable content quality limitations.
+
+### What Works Well
+- Multi-agent coordination (Manager → Search → Hypothesis → Report)
+- Clean streaming output (no garbage tokens, no raw JSON)
+- Proper agent handoffs and progress tracking
+- Coherent narrative structure
+
+### Known Limitations
+
+| Issue | Description | Severity |
+|-------|-------------|----------|
+| **Hallucinated Citations** | Model generates plausible-sounding but fake paper titles/authors instead of using actual search results | Medium |
+| **Anatomical Confusion** | May apply male anatomy (e.g., "penile rigidity") to female health queries | High |
+| **Nonsensical Medical Claims** | May generate claims like "prostate cancer risk" in context of female patients | High |
+| **Duplicate Content** | Final reports sometimes contain repeated sections | Low |
+
+### Why This Happens
+
+7B parameter models have limited:
+- **World knowledge**: Can't reliably recall specific paper titles/authors
+- **Context grounding**: May ignore search results and hallucinate instead
+- **Domain reasoning**: Complex medical topics exceed reasoning capacity
+
+### User Guidance
+
+**Free Tier is best for:**
+- Understanding the research workflow
+- Getting general topic overviews
+- Testing the system before committing to paid tier
+
+**For accurate medical research:**
+- Use Paid Tier (GPT-5) for citation accuracy
+- Always verify citations against actual databases
+- Treat Free Tier output as "draft quality"
+
+### Not a Stack Bug
+
+These are **model capability limitations**, not bugs in the DeepBoner architecture. The orchestration, streaming, and agent coordination are working correctly.
+
 ---
 *Analysis performed by Gemini CLI Agent, Dec 2, 2025*
+*Content quality section added Dec 3, 2025*

docs/bugs/ACTIVE_BUGS.md

@@ -1,6 +1,6 @@
 # Active Bugs
 
-> Last updated: 2025-12-03
+> Last updated: 2025-12-04
 >
 > **Note:** Completed bug docs archived to `docs/bugs/archive/`
 > **See also:** [ARCHITECTURE.md](../ARCHITECTURE.md) for unified architecture plan
@@ -33,6 +33,17 @@
 
 ---
 
+### P3 - Remove Modal Integration
+
+**File:** `docs/future-roadmap/P3_MODAL_INTEGRATION_REMOVAL.md`
+**Status:** OPEN - Tech Debt
+
+**Problem:** Modal (cloud functions) is integrated in 9 files but was decided against for this project. Creates dead code paths and confusion.
+
+**Fix:** Remove all Modal references from codebase (config, services, agents, tools).
+
+---
+
 ## Resolved Bugs (December 2025)
 
 All resolved bugs have been moved to `docs/bugs/archive/`. Summary:
@@ -55,6 +66,8 @@ All resolved bugs have been moved to `docs/bugs/archive/`. Summary:
 - **P1 Simple Mode Removed Breaks Free Tier UX** - FIXED via Accumulator Pattern (PR #117)
 
 ### P2 Bugs (All FIXED)
+- **P2 Duplicate Report Content** - FIXED in PR fix/p2-double-bug-squash, stateful deduplication in `run()` loop
+- **P2 First Turn Timeout** - FIXED in PR fix/p2-double-bug-squash, reduced results per tool (10→5), increased timeout (5→10 min)
 - **P2 7B Model Garbage Output** - SUPERSEDED by P1 Free Tier fix (root cause was premature marker, not model capacity)
 - **P2 Advanced Mode Cold Start No Feedback** - FIXED, all phases complete
 - **P2 Architectural BYOK Gaps** - FIXED, end-to-end BYOK support in PR #119

docs/bugs/P2_DUPLICATE_REPORT_CONTENT.md

@@ -0,0 +1,151 @@
+# P2 Bug: Duplicate Report Content in Output
+
+**Date**: 2025-12-03
+**Status**: FIXED (PR fix/p2-double-bug-squash)
+**Severity**: P2 (UX - Duplicate content confuses users)
+**Component**: `src/orchestrators/advanced.py`
+**Affects**: Both Free Tier (HuggingFace) AND Paid Tier (OpenAI)
+
+---
+
+## Executive Summary
+
+This is a **confirmed stack bug**, NOT a model limitation. The duplicate report appears because:
+
+1. Streaming events yield the full report content character-by-character
+2. Final events (`MagenticFinalResultEvent`/`WorkflowOutputEvent`) contain the SAME content
+3. No deduplication exists between streamed content and final event content
+4. Both are appended to the output
+
+---
+
+## Symptom
+
+The final research report appears **twice** in the UI output:
+1. First as streaming content (with `📡 **STREAMING**:` prefix)
+2. Then again as a complete event (without prefix)
+
+---
+
+## Root Cause
+
+The `_process_event()` method handles final events but has **no access to buffer state**. The buffer was already cleared at line 337 before these events arrive.
+
+```python
+# Line 337: Buffer cleared
+current_message_buffer = ""
+continue
+
+# Line 341: Final events processed WITHOUT buffer context
+agent_event = self._process_event(event, iteration)  # No buffer info!
+```
+
+---
+
+## The Fix (Consensus: Stateful Orchestrator Logic)
+
+**Location**: `src/orchestrators/advanced.py` `run()` method
+
+**Strategy**: Handle final events **inline in the run() loop** where buffer state exists. Track streaming volume to decide whether to re-emit content.
+
+### Why This Is Correct
+
+| Rejected Approach | Why Wrong |
+|-------------------|-----------|
+| UI-side string comparison | Wrong layer, fragile, treats symptom |
+| Stateless `_process_event` fix | No state = can't know if streaming occurred |
+| **Stateful run() loop** | ✅ Only place with full lifecycle visibility |
+
+The `run()` loop is the **single source of truth** for the request lifecycle. It "saw" the content stream out. It must decide whether to re-emit.
+
+### Implementation
+
+```python
+# In run() method, add tracking variable after line 302:
+last_streamed_length: int = 0
+
+# Before clearing buffer at line 337, save its length:
+last_streamed_length = len(current_message_buffer)
+current_message_buffer = ""
+continue
+
+# Replace lines 340-345 with inline handling of final events:
+if isinstance(event, (MagenticFinalResultEvent, WorkflowOutputEvent)):
+    final_event_received = True
+
+    # DECISION: Did we stream substantial content?
+    if last_streamed_length > 100:
+        # YES: Final event is a SIGNAL, not a payload
+        yield AgentEvent(
+            type="complete",
+            message="Research complete.",
+            data={"iterations": iteration, "streamed_chars": last_streamed_length},
+            iteration=iteration,
+        )
+    else:
+        # NO: Final event must carry the payload (tool-only turn, cache hit)
+        if isinstance(event, MagenticFinalResultEvent):
+            text = self._extract_text(event.message) if event.message else "No result"
+        else:  # WorkflowOutputEvent
+            text = self._extract_text(event.data) if event.data else "Research complete"
+        yield AgentEvent(
+            type="complete",
+            message=text,
+            data={"iterations": iteration},
+            iteration=iteration,
+        )
+    continue
+
+# Keep existing fallback for other events:
+agent_event = self._process_event(event, iteration)
+```
+
+### Why Threshold of 100 Chars?
+
+- `> 0` is too aggressive (might catch single-word streams)
+- `> 500` is too conservative (might miss short but complete responses)
+- `> 100` distinguishes "real content was streamed" from "just status messages"
+
+---
+
+## Edge Cases Handled
+
+| Scenario | `last_streamed_length` | Action |
+|----------|------------------------|--------|
+| Normal streaming report | 5000+ | Emit "Research complete." |
+| Tool call, no text | 0 | Emit full content from final event |
+| Very short response | 50 | Emit full content (fallback) |
+| Agent switch mid-stream | Reset on switch | Tracks only final agent |
+
+---
+
+## Files to Modify
+
+| File | Lines | Change |
+|------|-------|--------|
+| `src/orchestrators/advanced.py` | 296-345 | Add `last_streamed_length`, handle final events inline |
+| `src/orchestrators/advanced.py` | 532-552 | Optional: remove dead code from `_process_event()` |
+
+---
+
+## Test Plan
+
+1. **Happy Path**: Run query, verify report appears ONCE
+2. **Fallback**: Mock tool-only turn (no streaming), verify full content emitted
+3. **Both Tiers**: Test Free Tier and Paid Tier
+
+---
+
+## Validation
+
+This fix was independently validated by two AI agents (Claude and Gemini) analyzing the architecture. Both concluded:
+
+> "The Stateful Orchestrator Fix is the correct engineering solution. The 'Source of Truth' is the Orchestrator's runtime state."
+
+---
+
+## Related
+
+- **Not related to model quality** - This is a stack bug
+- P1 Free Tier fix enabled streaming, exposing this bug
+- SPEC-17 Accumulator Pattern addressed repr bug but created this side effect

docs/bugs/P2_FIRST_TURN_TIMEOUT.md

@@ -0,0 +1,160 @@
+# P2 Bug: First Agent Turn Exceeds Workflow Timeout
+
+**Date**: 2025-12-03
+**Status**: FIXED (PR fix/p2-double-bug-squash)
+**Severity**: P2 (UX - Workflow always times out on complex queries)
+**Component**: `src/orchestrators/advanced.py` + `src/agents/search_agent.py`
+**Affects**: Both Free Tier (HuggingFace) AND Paid Tier (OpenAI)
+
+---
+
+## Executive Summary
+
+The search agent's first turn can exceed the 5-minute workflow timeout, causing:
+1. `iterations=0` at timeout (no agent completed a turn)
+2. `_handle_timeout()` synthesizes from partial evidence
+3. Users get incomplete research results
+
+This is a **performance/architecture bug**, not a model issue.
+
+---
+
+## Symptom
+
+```
+[warning] Workflow timed out             iterations=0
+```
+
+The workflow times out with `iterations=0` - meaning the first agent (search agent) never completed its turn before the 5-minute timeout.
+
+---
+
+## Root Cause
+
+The search agent's first turn is **extremely expensive**:
+
+```
+Search Agent First Turn:
+├── Manager assigns task
+├── Search agent starts
+│   ├── Calls PubMed search tool (10 results)
+│   ├── Calls ClinicalTrials search tool (10 results)
+│   ├── Calls EuropePMC search tool (10 results)
+│   └── For EACH result (30 total):
+│       ├── Generate embedding (OpenAI API call)
+│       ├── Check for duplicates (ChromaDB query)
+│       └── Store in ChromaDB
+│
+│   TOTAL: 30 results × (embedding + dedup + store) = 90+ API/DB operations
+│
+└── Agent turn completes (if timeout hasn't fired)
+```
+
+**The timeout is on the WORKFLOW, not individual agent turns.** A single greedy agent can consume the entire timeout budget.
+
+---
+
+## Impact
+
+| Aspect | Impact |
+|--------|--------|
+| UX | Queries always timeout on first turn |
+| Research quality | Synthesis happens on partial evidence |
+| Confusion | `iterations=0` looks like nothing happened |
+
+---
+
+## The Fix (Consensus)
+
+**Reduce work per turn + increase timeout budget.**
+
+### Implementation
+
+**1. Reduce results per tool (immediate)**
+
+`src/agents/search_agent.py` line 70:
+```python
+# Change from 10 to 5
+result: SearchResult = await self._handler.execute(query, max_results_per_tool=5)
+```
+
+**2. Increase workflow timeout (immediate)**
+
+`src/utils/config.py`:
+```python
+advanced_timeout: float = Field(
+    default=600.0,  # Was 300.0 (5 min), now 10 min
+    ge=60.0,
+    le=900.0,
+    description="Timeout for Advanced mode in seconds",
+)
+```
+
+### Why NOT Per-Turn Timeout
+
+**DANGER**: The SearchHandler uses `asyncio.gather()`:
+
+```python
+# src/tools/search_handler.py line 163-164
+results = await asyncio.gather(*tasks, return_exceptions=True)
+```
+
+This is an **all-or-nothing** operation. If you wrap it with `asyncio.timeout()` and the timeout fires, you get **zero results**, not partial results.
+
+```python
+# DON'T DO THIS - yields nothing on timeout
+async with asyncio.timeout(60):
+    result = await self._handler.execute(query)  # Cancelled = zero results
+```
+
+Per-turn timeout requires `SearchHandler` to support cancellation with partial results. That's a separate architectural change (see Future Work).
+
+---
+
+## Future Work (Streaming Evidence Ingestion)
+
+For proper fix, `SearchHandler.execute()` should:
+1. Yield results as they arrive (async generator)
+2. Support cancellation with partial results
+3. Allow agent to return "what we have so far" on timeout
+
+```python
+# Future architecture
+async def execute_streaming(self, query: str) -> AsyncIterator[Evidence]:
+    for tool in self.tools:
+        async for evidence in tool.search_streaming(query):
+            yield evidence  # Can be cancelled at any point
+```
+
+This is out of scope for the immediate fix.
+
+---
+
+## Test Plan
+
+1. Run query with 10-minute timeout
+2. Verify first agent turn completes before timeout
+3. Verify `iterations >= 1` at workflow end
+
+---
+
+## Verification Data
+
+From diagnostic run:
+```
+=== RAW FRAMEWORK EVENTS ===
+  MagenticAgentDeltaEvent: 284
+  MagenticOrchestratorMessageEvent: 3
+  ...
+  NO MagenticAgentMessageEvent  ← Agent never completed a turn!
+
+[warning] Workflow timed out             iterations=0
+```
+
+---
+
+## Related
+
+- P2 Duplicate Report Bug (separate issue, happens after successful completion)
+- `_handle_timeout()` correctly synthesizes, but with partial evidence
+- Not related to model quality - this is infrastructure/performance

docs/future-roadmap/P3_MODAL_INTEGRATION_REMOVAL.md

@@ -0,0 +1,78 @@
+# P3 Tech Debt: Modal Integration Removal
+
+**Date**: 2025-12-04
+**Status**: OPEN - Tech Debt (Future Roadmap)
+**Severity**: P3 (Tech Debt - Not blocking functionality)
+**Component**: Multiple files
+
+---
+
+## Executive Summary
+
+Modal (cloud function execution platform) is integrated throughout the codebase but was decided against for this project. This creates potential confusion and dead code paths that should be cleaned up when time permits.
+
+---
+
+## Affected Files
+
+The following files contain Modal references:
+
+| File | Usage |
+|------|-------|
+| `src/utils/config.py` | `MODAL_TOKEN_ID`, `MODAL_TOKEN_SECRET` settings |
+| `src/utils/service_loader.py` | Modal service initialization |
+| `src/services/llamaindex_rag.py` | Modal integration for RAG |
+| `src/agents/code_executor_agent.py` | Modal sandbox execution |
+| `src/utils/exceptions.py` | Modal-related exceptions |
+| `src/tools/code_execution.py` | Modal code execution tool |
+| `src/services/statistical_analyzer.py` | Modal statistical analysis |
+| `src/mcp_tools.py` | Modal MCP tool wrappers |
+| `src/agents/analysis_agent.py` | Modal analysis agent |
+
+---
+
+## Context
+
+Modal was originally integrated for:
+1. **Code Execution Sandbox**: Running untrusted code in isolated containers
+2. **Statistical Analysis**: Offloading heavy statistical computations
+3. **LlamaIndex RAG**: Premium embeddings with persistent storage
+
+However, the project decided against Modal because:
+- Added infrastructure complexity
+- Free Tier doesn't need cloud functions
+- Paid Tier uses OpenAI directly
+
+---
+
+## Recommended Fix
+
+1. Remove Modal-related code from all affected files
+2. Remove `MODAL_TOKEN_ID` and `MODAL_TOKEN_SECRET` from config
+3. Remove Modal from dependencies in `pyproject.toml`
+4. Update any documentation referencing Modal
+
+---
+
+## Impact If Not Fixed
+
+- Confusion for new contributors
+- Dead code in production
+- Unnecessary dependencies
+- Config settings that do nothing
+
+---
+
+## Test Plan
+
+1. Remove Modal code
+2. Run `make check` to ensure no breakage
+3. Verify Free Tier and Paid Tier still work
+4. Search codebase for any remaining Modal references
+
+---
+
+## Related
+
+- `P3_REMOVE_ANTHROPIC_PARTIAL_WIRING.md` - Similar tech debt for Anthropic
+- ARCHITECTURE.md - Current architecture excludes Modal

docs/index.md

@@ -103,5 +103,5 @@ User Question → Research Agent (Orchestrator)
 |-------|--------|
 | Phases 1-14 | ✅ COMPLETE |
 
-**Tests**: 142+ passing, 0 warnings
+**Tests**: 318 passing, 0 warnings
 **Known Issues**: See [Active Bugs](bugs/ACTIVE_BUGS.md)

src/agents/search_agent.py

@@ -67,7 +67,7 @@ class SearchAgent(BaseAgent):  # type: ignore[misc]
             )
 
         # Execute search
-        result: SearchResult = await self._handler.execute(query, max_results_per_tool=10)
+        result: SearchResult = await self._handler.execute(query, max_results_per_tool=5)
 
         # Track what to show in response (initialized to search results as default)
         evidence_to_show: list[Evidence] = result.evidence

src/orchestrators/advanced.py

@@ -301,6 +301,7 @@ The final output should be a structured research report."""
         # to repr(message) if text is empty. We must reconstruct text from Deltas.
         current_message_buffer: str = ""
         current_agent_id: str | None = None
+        last_streamed_length: int = 0  # Track for P2 Duplicate Report Bug Fix
 
         try:
             async with asyncio.timeout(self._timeout_seconds):
@@ -333,15 +334,21 @@ The final output should be a structured research report."""
                         yield comp_event
                         yield prog_event
 
+                        # P2 BUG FIX: Save length before clearing
+                        last_streamed_length = len(current_message_buffer)
                         # Clear buffer after consuming
                         current_message_buffer = ""
                         continue
 
-                    # 3. Handle other events normally
+                    # 3. Handle Final Events Inline (P2 Duplicate Report Fix)
+                    if isinstance(event, (MagenticFinalResultEvent, WorkflowOutputEvent)):
+                        final_event_received = True
+                        yield self._handle_final_event(event, iteration, last_streamed_length)
+                        continue
+
+                    # 4. Handle other events normally
                     agent_event = self._process_event(event, iteration)
                     if agent_event:
-                        if agent_event.type == "complete":
-                            final_event_received = True
                         yield agent_event
 
             # GUARANTEE: Always emit termination event if stream ends without one
@@ -413,6 +420,40 @@ The final output should be a structured research report."""
 
         return completion_event, progress_event
 
+    def _handle_final_event(
+        self,
+        event: MagenticFinalResultEvent | WorkflowOutputEvent,
+        iteration: int,
+        last_streamed_length: int,
+    ) -> AgentEvent:
+        """Handle final workflow events with duplicate content suppression (P2 Bug Fix)."""
+        # DECISION: Did we stream substantial content?
+        if last_streamed_length > 100:
+            # YES: Final event is a SIGNAL, not a payload
+            return AgentEvent(
+                type="complete",
+                message="Research complete.",
+                data={
+                    "iterations": iteration,
+                    "streamed_chars": last_streamed_length,
+                },
+                iteration=iteration,
+            )
+
+        # NO: Final event must carry the payload (tool-only turn, cache hit)
+        text = ""
+        if isinstance(event, MagenticFinalResultEvent):
+            text = self._extract_text(event.message) if event.message else "No result"
+        elif isinstance(event, WorkflowOutputEvent):
+            text = self._extract_text(event.data) if event.data else "Research complete"
+
+        return AgentEvent(
+            type="complete",
+            message=text,
+            data={"iterations": iteration},
+            iteration=iteration,
+        )
+
     def _extract_text(self, message: Any) -> str:
         """
         Defensively extract text from a message object.
@@ -526,30 +567,12 @@ The final output should be a structured research report."""
                 iteration=iteration,
             )
 
-        # NOTE: MagenticAgentMessageEvent is handled in run() loop with Accumulator Pattern
-        # (see lines 322-335) and never reaches this method due to `continue` statement.
-
-        elif isinstance(event, MagenticFinalResultEvent):
-            text = self._extract_text(event.message) if event.message else "No result"
-            return AgentEvent(
-                type="complete",
-                message=text,
-                data={"iterations": iteration},
-                iteration=iteration,
-            )
-
-        # NOTE: MagenticAgentDeltaEvent is handled in run() loop with Accumulator Pattern
-        # (see lines 306-320) and never reaches this method due to `continue` statement.
-
-        elif isinstance(event, WorkflowOutputEvent):
-            if event.data:
-                # Use _extract_text to properly handle ChatMessage objects
-                text = self._extract_text(event.data)
-                return AgentEvent(
-                    type="complete",
-                    message=text if text else "Research complete (no synthesis)",
-                    iteration=iteration,
-                )
+        # NOTE: The following event types are handled inline in run() loop and never reach
+        # this method due to `continue` statements:
+        # - MagenticAgentMessageEvent: Accumulator Pattern (lines 322-335)
+        # - MagenticAgentDeltaEvent: Accumulator Pattern (lines 306-320)
+        # - MagenticFinalResultEvent: P2 Duplicate Fix via _handle_final_event() (lines 343-347)
+        # - WorkflowOutputEvent: P2 Duplicate Fix via _handle_final_event() (lines 343-347)
 
         return None
 

src/utils/config.py

@@ -71,10 +71,10 @@ class Settings(BaseSettings):
         description="Max coordination rounds for Advanced mode (default 5 for faster demos)",
     )
     advanced_timeout: float = Field(
-        default=300.0,
+        default=600.0,
         ge=60.0,
         le=900.0,
-        description="Timeout for Advanced mode in seconds (default 5 min)",
+        description="Timeout for Advanced mode in seconds (default 10 min)",
     )
     search_timeout: int = Field(default=30, description="Seconds to wait for search")
     magentic_timeout: int = Field(

tests/unit/agents/test_search_agent.py

@@ -47,7 +47,7 @@ async def test_run_executes_search(mock_handler: AsyncMock) -> None:
     response = await agent.run("test query")
 
     # Check handler called
-    mock_handler.execute.assert_awaited_once_with("test query", max_results_per_tool=10)
+    mock_handler.execute.assert_awaited_once_with("test query", max_results_per_tool=5)
 
     # Check store updated
     assert len(store["current"]) == 1
@@ -67,7 +67,7 @@ async def test_run_handles_chat_message_input(mock_handler: AsyncMock) -> None:
     message = ChatMessage(role=Role.USER, text="test query")
     await agent.run(message)
 
-    mock_handler.execute.assert_awaited_once_with("test query", max_results_per_tool=10)
+    mock_handler.execute.assert_awaited_once_with("test query", max_results_per_tool=5)
 
 
 @pytest.mark.asyncio
@@ -81,7 +81,7 @@ async def test_run_handles_list_input(mock_handler: AsyncMock) -> None:
         ChatMessage(role=Role.USER, text="test query"),
     ]
     await agent.run(messages)
-    mock_handler.execute.assert_awaited_once_with("test query", max_results_per_tool=10)
+    mock_handler.execute.assert_awaited_once_with("test query", max_results_per_tool=5)
 
 
 @pytest.mark.asyncio

tests/unit/orchestrators/test_advanced_orchestrator.py

@@ -28,11 +28,11 @@ class TestAdvancedOrchestratorConfig:
         assert orch._max_rounds == 7
 
     @patch("src.orchestrators.advanced.get_chat_client")
-    def test_timeout_default_is_five_minutes(self, mock_get_client) -> None:
-        """Default timeout should be 300s (5 min) from settings."""
+    def test_timeout_default_is_ten_minutes(self, mock_get_client: MagicMock) -> None:
+        """Test that default timeout is 10 minutes (P2 fix)."""
         mock_get_client.return_value = MagicMock()
         orch = AdvancedOrchestrator()
-        assert orch._timeout_seconds == 300.0
+        assert orch._timeout_seconds == 600.0
 
     @patch("src.orchestrators.advanced.get_chat_client")
     def test_explicit_timeout_overrides_settings(self, mock_get_client) -> None: