Merge pull request #91 from The-Obstacle-Is-The-Way/main

feat(SPEC_11): Sexual Health Research Specialist + SPEC_12 docs

BRAINSTORM_EMBEDDINGS_META.md

@@ -0,0 +1,74 @@
+# Embeddings Brainstorm - Conclusions
+
+**Date**: November 2025
+**Status**: CLOSED - Conclusions reached, no action needed
+
+---
+
+## The Question
+
+Should DeepBoner implement:
+1. Internal codebase embeddings/ingestion pipeline?
+2. mGREP for internal tool selection?
+3. Self-knowledge components for agents?
+
+## The Answer: NO
+
+After research and first-principles analysis, the conclusion is clear:
+
+### Why Not Internal Embeddings/Ingestion
+
+```text
+DeepBoner's Core Task:
+┌─────────────────────────────────────────────────────────┐
+│  User Query: "Evidence for testosterone in HSDD?"       │
+│                         ↓                               │
+│  1. Search PubMed, ClinicalTrials, Europe PMC          │
+│  2. Judge: Is evidence sufficient?                      │
+│  3. Synthesize: Generate report                         │
+│                         ↓                               │
+│  Output: Research report with citations                 │
+└─────────────────────────────────────────────────────────┘
+
+Does ANY step require self-knowledge of codebase? NO.
+```
+
+### Why Not mGREP for Tool Selection
+
+| Approach | Complexity | Accuracy |
+|----------|------------|----------|
+| Embeddings + mGREP for tool selection | High | Medium (semantic similarity ≠ correct tool) |
+| Direct prompting with tool descriptions | Low | High (LLM reasons about applicability) |
+
+**No real agent system uses embeddings for tool selection.** All major frameworks (LangChain, OpenAI, Anthropic, Magentic) use prompt-based tool selection because:
+1. LLMs are already doing semantic matching internally
+2. Tool count is small (5-20) - fits easily in context
+3. Prompts allow reasoning, not just similarity
+
+### What We Already Have
+
+DeepBoner already uses embeddings for the **right thing**: research evidence retrieval.
+- `src/services/embeddings.py` - ChromaDB + sentence-transformers
+- `src/services/llamaindex_rag.py` - OpenAI embeddings for premium tier
+
+### The Real Priority
+
+Instead of internal embeddings/mGREP, focus on:
+1. **Deduplication** across PubMed/Europe PMC/OpenAlex
+2. **Outcome measures** from ClinicalTrials.gov
+3. **Citation graph traversal** via OpenAlex
+
+See: `TOOL_ANALYSIS_CRITICAL.md` for detailed improvement roadmap.
+
+---
+
+## Research Sources
+
+- [SICA Paper (ICLR 2025)](https://arxiv.org/abs/2504.15228) - Self-improving agents
+- [Gödel Agent (ACL 2025)](https://arxiv.org/abs/2410.04444) - Recursive self-modification
+- [Introspection Paradox (EMNLP 2025)](https://aclanthology.org/2025.emnlp-main.352/) - Self-knowledge can hurt performance
+- [Anthropic Introspection Research](https://www.anthropic.com/research/introspection) - ~20% accuracy on genuine introspection
+
+---
+
+*This document is closed. The conclusion is: don't implement internal embeddings/mGREP for this use case.*

SPEC_12_NARRATIVE_SYNTHESIS.md

@@ -0,0 +1,730 @@
+# SPEC_12: Narrative Report Synthesis
+
+**Status**: Ready for Implementation
+**Priority**: P1 - Core deliverable
+**Related Issues**: #85, #86
+**Related Spec**: SPEC_11 (Sexual Health Focus)
+**Author**: Deep Audit against Microsoft Agent Framework
+
+---
+
+## Problem Statement
+
+DeepBoner's report generation outputs **structured metadata** instead of **synthesized prose**. The current implementation uses string templating with NO LLM call for narrative synthesis.
+
+### Current Output (Simple Mode - What Users See)
+
+```markdown
+## Sexual Health Analysis
+
+### Question
+Testosterone therapy for hypoactive sexual desire disorder?
+
+### Drug Candidates
+- **Testosterone**
+- **LibiGel**
+
+### Key Findings
+- Testosterone therapy improves sexual desire
+
+### Assessment
+- **Mechanism Score**: 8/10
+- **Clinical Evidence Score**: 9/10
+- **Confidence**: 90%
+
+### Citations (33 sources)
+1. [Title](url)...
+```
+
+### Expected Output (Professional Research Report)
+
+```markdown
+## Sexual Health Research Report: Testosterone Therapy for HSDD
+
+### Executive Summary
+
+Testosterone therapy represents a well-established, evidence-based treatment for
+hypoactive sexual desire disorder (HSDD) in postmenopausal women. Our analysis of
+33 peer-reviewed sources reveals consistent findings across multiple randomized
+controlled trials, with transdermal testosterone demonstrating the strongest
+efficacy-safety profile.
+
+### Background
+
+Hypoactive sexual desire disorder affects an estimated 12% of postmenopausal women
+and is characterized by persistent lack of sexual interest causing personal distress.
+The ISSWSH published clinical guidelines in 2021 establishing testosterone as a
+recommended intervention...
+
+### Evidence Synthesis
+
+**Mechanism of Action**
+
+Testosterone exerts its effects on sexual desire through multiple pathways. At the
+hypothalamic level, testosterone modulates dopaminergic signaling. Evidence from
+Smith et al. (2021) demonstrates androgen receptor activation correlates with
+subjective measures of desire (r=0.67, p<0.001)...
+
+### Recommendations
+
+1. **Transdermal testosterone** (300 μg/day) is recommended for postmenopausal
+   women with HSDD not primarily related to modifiable factors
+2. **Duration**: Continue for 6 months to assess efficacy; discontinue if no benefit
+
+### Limitations
+
+Long-term safety data beyond 24 months remains limited...
+
+### References
+1. Smith AB et al. (2021). Testosterone mechanisms... https://pubmed.ncbi.nlm.nih.gov/123/
+```
+
+---
+
+## Root Cause Analysis
+
+### Location 1: Simple Orchestrator (THE PRIMARY BUG)
+
+**File**: `src/orchestrators/simple.py`
+**Lines**: 448-505
+**Method**: `_generate_synthesis()`
+
+```python
+def _generate_synthesis(
+    self,
+    query: str,
+    evidence: list[Evidence],
+    assessment: JudgeAssessment,
+) -> str:
+    # ❌ NO LLM CALL - Just string templating!
+    drug_list = "\n".join([f"- **{d}**" for d in assessment.details.drug_candidates])
+    findings_list = "\n".join([f"- {f}" for f in assessment.details.key_findings])
+
+    return f"""{self.domain_config.report_title}
+### Question
+{query}
+### Drug Candidates
+{drug_list}
+...
+"""
+```
+
+**The Problem**: No LLM is ever called. It's just formatted data from JudgeAssessment.
+
+### Location 2: Partial Synthesis (Max Iterations Fallback)
+
+**File**: `src/orchestrators/simple.py`
+**Lines**: 507-602
+**Method**: `_generate_partial_synthesis()`
+
+Same issue - string templating, no LLM call.
+
+### Location 3: Report Agent (Advanced Mode)
+
+**File**: `src/agents/report_agent.py`
+**Lines**: 93-94
+
+```python
+result = await self._get_agent().run(prompt)
+report = result.output  # ResearchReport (structured data)
+```
+
+This DOES make an LLM call, but it outputs `ResearchReport` (structured Pydantic model), not narrative prose. The `to_markdown()` method just formats the structured fields.
+
+### Location 4: Report System Prompt
+
+**File**: `src/prompts/report.py`
+**Lines**: 13-76
+
+The system prompt tells the LLM to output structured JSON with fields like `hypotheses_tested: [...]` and `references: [...]`. It does NOT request narrative prose.
+
+---
+
+## Microsoft Agent Framework Pattern (Reference)
+
+**File**: `reference_repos/agent-framework/python/samples/getting_started/workflows/orchestration/concurrent_custom_aggregator.py`
+**Lines**: 56-79
+
+```python
+# Define a custom aggregator callback that uses the chat client to SYNTHESIZE
+async def summarize_results(results: list[Any]) -> str:
+    expert_sections: list[str] = []
+    for r in results:
+        messages = getattr(r.agent_run_response, "messages", [])
+        final_text = messages[-1].text if messages else "(no content)"
+        expert_sections.append(f"{r.executor_id}:\n{final_text}")
+
+    # ✅ LLM CALL for synthesis
+    system_msg = ChatMessage(
+        Role.SYSTEM,
+        text=(
+            "You are a helpful assistant that consolidates multiple domain expert outputs "
+            "into one cohesive, concise summary with clear takeaways."
+        ),
+    )
+    user_msg = ChatMessage(Role.USER, text="\n\n".join(expert_sections))
+
+    response = await chat_client.get_response([system_msg, user_msg])
+    return response.messages[-1].text
+```
+
+**The pattern**: The aggregator makes an **LLM call** to synthesize, not string concatenation.
+
+---
+
+## Solution Design
+
+### Architecture Change
+
+```text
+Current (Simple Mode):
+  Evidence → Judge → {structured data} → String Template → Bullet Points
+
+Proposed (Simple Mode):
+  Evidence → Judge → {structured data} → LLM Synthesis → Narrative Prose
+                                              ↓
+                                     Uses SynthesisPrompt
+```
+
+### Components to Create/Modify
+
+| File | Action | Description |
+|------|--------|-------------|
+| `src/prompts/synthesis.py` | **NEW** | Narrative synthesis prompts |
+| `src/orchestrators/simple.py` | **MODIFY** | Make `_generate_synthesis()` async, add LLM call |
+| `src/config/domain.py` | **MODIFY** | Add `synthesis_system_prompt` field |
+| `tests/unit/prompts/test_synthesis.py` | **NEW** | Test synthesis prompts |
+| `tests/unit/orchestrators/test_simple_synthesis.py` | **NEW** | Test LLM synthesis |
+
+---
+
+## Implementation Plan
+
+### Phase 1: Create Synthesis Prompts
+
+**File**: `src/prompts/synthesis.py` (NEW)
+
+```python
+"""Prompts for narrative report synthesis."""
+
+from src.config.domain import ResearchDomain, get_domain_config
+
+def get_synthesis_system_prompt(domain: ResearchDomain | str | None = None) -> str:
+    """Get the system prompt for narrative synthesis."""
+    config = get_domain_config(domain)
+    return f"""You are a scientific writer specializing in {config.name.lower()}.
+Your task is to synthesize research evidence into a clear, NARRATIVE report.
+
+## CRITICAL: Writing Style
+- Write in PROSE PARAGRAPHS, not bullet points
+- Use academic but accessible language
+- Be specific about evidence strength (e.g., "in an RCT of N=200")
+- Reference specific studies by author name
+- Provide quantitative results where available (p-values, effect sizes)
+
+## Report Structure
+
+### Executive Summary (REQUIRED - 2-3 sentences)
+Start with the bottom line. Example:
+"Testosterone therapy demonstrates consistent efficacy for HSDD in postmenopausal
+women, with transdermal formulations showing the best safety profile."
+
+### Background (REQUIRED - 1 paragraph)
+Explain the condition, its prevalence, and clinical significance.
+
+### Evidence Synthesis (REQUIRED - 2-4 paragraphs)
+Weave the evidence into a coherent NARRATIVE:
+- Mechanism of Action: How does the intervention work?
+- Clinical Evidence: What do trials show? Include effect sizes.
+- Comparative Evidence: How does it compare to alternatives?
+
+### Recommendations (REQUIRED - 3-5 items)
+Provide actionable clinical recommendations.
+
+### Limitations (REQUIRED - 1 paragraph)
+Acknowledge gaps, biases, and areas needing more research.
+
+### References (REQUIRED)
+List key references with author, year, title, URL.
+
+## CRITICAL RULES
+1. ONLY cite papers from the provided evidence - NEVER hallucinate references
+2. Write in complete sentences and paragraphs (PROSE, not lists)
+3. Include specific statistics when available
+4. Acknowledge uncertainty honestly
+"""
+
+
+FEW_SHOT_EXAMPLE = '''
+## Example: Strong Evidence Synthesis
+
+INPUT:
+- Query: "Alprostadil for erectile dysfunction"
+- Evidence: 15 papers including meta-analysis of 8 RCTs (N=3,247)
+- Mechanism Score: 9/10
+- Clinical Score: 9/10
+
+OUTPUT:
+
+### Executive Summary
+
+Alprostadil (prostaglandin E1) represents a well-established second-line treatment
+for erectile dysfunction, with meta-analytic evidence demonstrating 87% efficacy
+in achieving erections sufficient for intercourse. It offers a PDE5-independent
+mechanism particularly valuable for patients who do not respond to oral therapies.
+
+### Background
+
+Erectile dysfunction affects approximately 30 million men in the United States,
+with prevalence increasing with age. While PDE5 inhibitors remain first-line
+therapy, approximately 30% of patients are non-responders. Alprostadil provides
+an alternative mechanism through direct smooth muscle relaxation.
+
+### Evidence Synthesis
+
+**Mechanism of Action**
+
+Alprostadil works through a distinct pathway from PDE5 inhibitors. It binds to
+EP receptors on cavernosal smooth muscle, activating adenylate cyclase and
+increasing intracellular cAMP. As noted by Smith et al. (2019), this mechanism
+explains its efficacy in patients with endothelial dysfunction.
+
+**Clinical Evidence**
+
+A meta-analysis by Johnson et al. (2020) pooled data from 8 randomized controlled
+trials (N=3,247). The primary endpoint of erection sufficient for intercourse was
+achieved in 87% of alprostadil patients versus 12% placebo (RR 7.25, 95% CI:
+5.8-9.1, p<0.001). The NNT was 1.3, indicating robust effect size.
+
+### Recommendations
+
+1. Consider alprostadil as second-line therapy when PDE5 inhibitors fail
+2. Start with 10 μg intracavernosal injection, titrate to 40 μg
+3. Provide in-office training for self-injection technique
+
+### Limitations
+
+Long-term data beyond 2 years is limited. Head-to-head comparisons with newer
+therapies are lacking. Most trials excluded severe cardiovascular disease.
+
+### References
+
+1. Smith AB et al. (2019). Alprostadil mechanism. J Urol. https://pubmed.ncbi.nlm.nih.gov/123/
+2. Johnson CD et al. (2020). Meta-analysis of alprostadil. J Sex Med. https://pubmed.ncbi.nlm.nih.gov/456/
+'''
+
+
+def format_synthesis_prompt(
+    query: str,
+    evidence_summary: str,
+    drug_candidates: list[str],
+    key_findings: list[str],
+    mechanism_score: int,
+    clinical_score: int,
+    confidence: float,
+) -> str:
+    """Format the user prompt for synthesis."""
+    return f"""Synthesize a narrative research report for the following query.
+
+## Research Question
+{query}
+
+## Evidence Summary
+{evidence_summary}
+
+## Identified Drug Candidates
+{', '.join(drug_candidates) or 'None identified'}
+
+## Key Findings from Evidence
+{chr(10).join(f'- {f}' for f in key_findings) or 'No specific findings'}
+
+## Assessment Scores
+- Mechanism Score: {mechanism_score}/10
+- Clinical Evidence Score: {clinical_score}/10
+- Confidence: {confidence:.0%}
+
+## Instructions
+Generate a NARRATIVE research report following the structure above.
+Write in prose paragraphs, NOT bullet points (except for Recommendations).
+ONLY cite papers mentioned in the Evidence Summary above.
+
+{FEW_SHOT_EXAMPLE}
+"""
+```
+
+### Phase 2: Update Simple Orchestrator
+
+**File**: `src/orchestrators/simple.py`
+**Change**: Make `_generate_synthesis()` async and add LLM call
+
+```python
+# Add imports at top
+from src.prompts.synthesis import get_synthesis_system_prompt, format_synthesis_prompt
+from src.agent_factory.judges import get_model
+from pydantic_ai import Agent
+
+# Change method signature and implementation (lines 448-505)
+async def _generate_synthesis(
+    self,
+    query: str,
+    evidence: list[Evidence],
+    assessment: JudgeAssessment,
+) -> str:
+    """
+    Generate the final synthesis response using LLM.
+
+    Args:
+        query: The original question
+        evidence: All collected evidence
+        assessment: The final assessment
+
+    Returns:
+        Narrative synthesis as markdown
+    """
+    # Build evidence summary for LLM context
+    evidence_lines = []
+    for e in evidence[:20]:  # Limit context
+        authors = ", ".join(e.citation.authors[:2]) if e.citation.authors else "Unknown"
+        evidence_lines.append(
+            f"- {e.citation.title} ({authors}, {e.citation.date}): {e.content[:200]}..."
+        )
+    evidence_summary = "\n".join(evidence_lines)
+
+    # Format synthesis prompt
+    user_prompt = format_synthesis_prompt(
+        query=query,
+        evidence_summary=evidence_summary,
+        drug_candidates=assessment.details.drug_candidates,
+        key_findings=assessment.details.key_findings,
+        mechanism_score=assessment.details.mechanism_score,
+        clinical_score=assessment.details.clinical_evidence_score,
+        confidence=assessment.confidence,
+    )
+
+    # Create synthesis agent
+    system_prompt = get_synthesis_system_prompt(self.domain)
+
+    try:
+        agent: Agent[None, str] = Agent(
+            model=get_model(),
+            output_type=str,
+            system_prompt=system_prompt,
+        )
+        result = await agent.run(user_prompt)
+        narrative = result.output
+    except Exception as e:
+        # Fallback to template if LLM fails
+        logger.warning("LLM synthesis failed, using template", error=str(e))
+        return self._generate_template_synthesis(query, evidence, assessment)
+
+    # Add citations footer
+    citations = "\n".join(
+        f"{i + 1}. [{e.citation.title}]({e.citation.url}) "
+        f"({e.citation.source.upper()}, {e.citation.date})"
+        for i, e in enumerate(evidence[:10])
+    )
+
+    return f"""{narrative}
+
+---
+### Full Citation List ({len(evidence)} sources)
+{citations}
+
+*Analysis based on {len(evidence)} sources across {len(self.history)} iterations.*
+"""
+
+def _generate_template_synthesis(
+    self,
+    query: str,
+    evidence: list[Evidence],
+    assessment: JudgeAssessment,
+) -> str:
+    """Fallback template synthesis (no LLM)."""
+    # Keep the existing string template logic here as fallback
+    ...
+```
+
+### Phase 3: Update Call Site
+
+**File**: `src/orchestrators/simple.py`
+**Line**: 393
+
+```python
+# Change from:
+final_response = self._generate_synthesis(query, all_evidence, assessment)
+
+# To:
+final_response = await self._generate_synthesis(query, all_evidence, assessment)
+```
+
+### Phase 4: Update Domain Config
+
+**File**: `src/config/domain.py`
+
+Add optional `synthesis_system_prompt` field to `DomainConfig`:
+
+```python
+class DomainConfig(BaseModel):
+    # ... existing fields ...
+
+    # Synthesis (optional, can inherit from base)
+    synthesis_system_prompt: str | None = None
+```
+
+### Phase 5: Add Tests
+
+**File**: `tests/unit/prompts/test_synthesis.py` (NEW)
+
+```python
+"""Tests for synthesis prompts."""
+
+import pytest
+
+from src.prompts.synthesis import (
+    get_synthesis_system_prompt,
+    format_synthesis_prompt,
+    FEW_SHOT_EXAMPLE,
+)
+
+
+def test_synthesis_system_prompt_is_narrative_focused() -> None:
+    """System prompt should emphasize prose, not bullets."""
+    prompt = get_synthesis_system_prompt()
+    assert "PROSE PARAGRAPHS" in prompt
+    assert "not bullet points" in prompt.lower()
+    assert "Executive Summary" in prompt
+
+
+def test_synthesis_system_prompt_warns_about_hallucination() -> None:
+    """System prompt should warn about citation hallucination."""
+    prompt = get_synthesis_system_prompt()
+    assert "NEVER hallucinate" in prompt
+
+
+def test_format_synthesis_prompt_includes_evidence() -> None:
+    """User prompt should include evidence summary."""
+    prompt = format_synthesis_prompt(
+        query="testosterone libido",
+        evidence_summary="Study shows efficacy...",
+        drug_candidates=["Testosterone"],
+        key_findings=["Improved libido"],
+        mechanism_score=8,
+        clinical_score=7,
+        confidence=0.85,
+    )
+    assert "testosterone libido" in prompt
+    assert "Study shows efficacy" in prompt
+    assert "Testosterone" in prompt
+    assert "8/10" in prompt
+
+
+def test_few_shot_example_is_narrative() -> None:
+    """Few-shot example should demonstrate narrative style."""
+    # Count paragraphs vs bullets
+    paragraphs = len([p for p in FEW_SHOT_EXAMPLE.split('\n\n') if len(p) > 100])
+    bullets = FEW_SHOT_EXAMPLE.count('\n- ')
+
+    # Prose should dominate (at least 2x more paragraphs than bullets)
+    assert paragraphs >= bullets, "Few-shot example should be mostly narrative"
+```
+
+**File**: `tests/unit/orchestrators/test_simple_synthesis.py` (NEW)
+
+```python
+"""Tests for simple orchestrator synthesis."""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from src.orchestrators.simple import Orchestrator
+from src.utils.models import Evidence, Citation, JudgeAssessment, JudgeDetails
+
+
+@pytest.fixture
+def sample_evidence() -> list[Evidence]:
+    return [
+        Evidence(
+            content="Testosterone therapy shows efficacy in HSDD treatment.",
+            citation=Citation(
+                source="pubmed",
+                title="Testosterone and Female Libido",
+                url="https://pubmed.ncbi.nlm.nih.gov/12345/",
+                date="2023",
+                authors=["Smith J"],
+            ),
+        )
+    ]
+
+
+@pytest.fixture
+def sample_assessment() -> JudgeAssessment:
+    return JudgeAssessment(
+        sufficient=True,
+        confidence=0.85,
+        reasoning="Evidence is sufficient",
+        recommendation="synthesize",
+        next_search_queries=[],
+        details=JudgeDetails(
+            mechanism_score=8,
+            clinical_evidence_score=7,
+            drug_candidates=["Testosterone"],
+            key_findings=["Improved libido in postmenopausal women"],
+        ),
+    )
+
+
+@pytest.mark.asyncio
+async def test_generate_synthesis_calls_llm(
+    sample_evidence: list[Evidence],
+    sample_assessment: JudgeAssessment,
+) -> None:
+    """Synthesis should make an LLM call, not just template."""
+    mock_search = MagicMock()
+    mock_judge = MagicMock()
+
+    orchestrator = Orchestrator(
+        search_handler=mock_search,
+        judge_handler=mock_judge,
+    )
+
+    with patch("src.orchestrators.simple.Agent") as mock_agent_class:
+        mock_agent = MagicMock()
+        mock_result = MagicMock()
+        mock_result.output = "This is a narrative synthesis with prose paragraphs."
+        mock_agent.run = AsyncMock(return_value=mock_result)
+        mock_agent_class.return_value = mock_agent
+
+        result = await orchestrator._generate_synthesis(
+            query="testosterone HSDD",
+            evidence=sample_evidence,
+            assessment=sample_assessment,
+        )
+
+        # Verify LLM was called
+        mock_agent_class.assert_called_once()
+        mock_agent.run.assert_called_once()
+
+        # Verify output includes narrative
+        assert "narrative synthesis" in result.lower() or "prose" in result.lower()
+
+
+@pytest.mark.asyncio
+async def test_generate_synthesis_falls_back_on_error(
+    sample_evidence: list[Evidence],
+    sample_assessment: JudgeAssessment,
+) -> None:
+    """Synthesis should fall back to template if LLM fails."""
+    mock_search = MagicMock()
+    mock_judge = MagicMock()
+
+    orchestrator = Orchestrator(
+        search_handler=mock_search,
+        judge_handler=mock_judge,
+    )
+
+    with patch("src.orchestrators.simple.Agent") as mock_agent_class:
+        mock_agent_class.side_effect = Exception("LLM unavailable")
+
+        result = await orchestrator._generate_synthesis(
+            query="testosterone HSDD",
+            evidence=sample_evidence,
+            assessment=sample_assessment,
+        )
+
+        # Should still return something (template fallback)
+        assert "Sexual Health Analysis" in result or "testosterone" in result.lower()
+```
+
+---
+
+## File Changes Summary
+
+| File | Lines | Change Type | Description |
+|------|-------|-------------|-------------|
+| `src/prompts/synthesis.py` | ~150 | NEW | Narrative synthesis prompts |
+| `src/orchestrators/simple.py` | 393, 448-505 | MODIFY | Async synthesis with LLM |
+| `src/config/domain.py` | 57 | MODIFY | Add `synthesis_system_prompt` |
+| `tests/unit/prompts/test_synthesis.py` | ~60 | NEW | Prompt tests |
+| `tests/unit/orchestrators/test_simple_synthesis.py` | ~80 | NEW | Synthesis tests |
+
+---
+
+## Acceptance Criteria
+
+- [ ] Report contains **paragraph-form prose**, not just bullet points
+- [ ] Report has **executive summary** (2-3 sentences)
+- [ ] Report has **background section** explaining the condition
+- [ ] Report has **synthesized narrative** weaving evidence together
+- [ ] Report has **actionable recommendations**
+- [ ] Report has **limitations** section
+- [ ] Citations are **properly formatted** (author, year, title, URL)
+- [ ] No hallucinated references (CRITICAL)
+- [ ] Falls back gracefully if LLM unavailable
+- [ ] All existing tests still pass
+- [ ] New tests achieve 90%+ coverage of synthesis code
+
+---
+
+## Test Criteria
+
+```python
+def test_report_is_narrative_not_bullets():
+    """Report should be mostly prose, not bullet points."""
+    report = await orchestrator._generate_synthesis(...)
+
+    # Count paragraphs vs bullet points
+    paragraphs = len([p for p in report.split('\n\n') if len(p) > 100])
+    bullets = report.count('\n- ')
+
+    # Prose should dominate
+    assert paragraphs > bullets, "Report should be narrative, not bullet list"
+
+def test_references_not_hallucinated():
+    """All references must come from provided evidence."""
+    evidence_urls = {e.citation.url for e in evidence}
+    report = await orchestrator._generate_synthesis(...)
+
+    # Extract URLs from report
+    import re
+    report_urls = set(re.findall(r'https?://[^\s\)]+', report))
+
+    for url in report_urls:
+        # Allow pubmed URLs even if slightly different format
+        if "pubmed" in url or "clinicaltrials" in url:
+            assert any(evidence_url in url or url in evidence_url
+                      for evidence_url in evidence_urls), f"Hallucinated: {url}"
+```
+
+---
+
+## Related Microsoft Agent Framework Patterns
+
+| Pattern | File | Application |
+|---------|------|-------------|
+| Custom Aggregator | `concurrent_custom_aggregator.py:56-79` | LLM-based synthesis |
+| Fan-Out/Fan-In | `fan_out_fan_in_edges.py` | Multi-expert synthesis |
+| Sequential Chain | `sequential_agents.py` | Writer→Reviewer pattern |
+
+---
+
+## Implementation Notes for Async Agent
+
+1. **Start with `src/prompts/synthesis.py`** - This is independent and can be created first
+2. **Then modify `src/orchestrators/simple.py`** - Change `_generate_synthesis` to async
+3. **Update the call site** (line 393) - Add `await`
+4. **Add tests** - Both unit and integration
+5. **Run `make check`** - Ensure all 237+ tests still pass
+
+The key insight from the MS Agent Framework is:
+> The aggregator makes an **LLM call** to synthesize, not string concatenation.
+
+Our `_generate_synthesis()` currently does NO LLM call. Fix that, and the reports will transform from bullet points to narrative prose.
+
+---
+
+## References
+
+- GitHub Issue #85: Report lacks narrative synthesis
+- GitHub Issue #86: Microsoft Agent Framework patterns
+- `reference_repos/agent-framework/python/samples/getting_started/workflows/orchestration/concurrent_custom_aggregator.py`
+- LangChain Deep Agents: Few-shot examples importance

TOOL_ANALYSIS_CRITICAL.md

@@ -0,0 +1,348 @@
+# Critical Analysis: Search Tools - Limitations, Gaps, and Improvements
+
+**Date**: November 2025
+**Purpose**: Honest assessment of all search tools to identify what's working, what's broken, and what needs improvement WITHOUT horizontal sprawl.
+
+---
+
+## Executive Summary
+
+DeepBoner currently has **4 search tools**:
+1. PubMed (NCBI E-utilities)
+2. ClinicalTrials.gov (API v2)
+3. Europe PMC (includes preprints)
+4. OpenAlex (citation-aware)
+
+**Overall Assessment**: Tools are functional but have significant gaps in:
+- Deduplication (PubMed ∩ Europe PMC ∩ OpenAlex = massive overlap)
+- Full-text retrieval (only abstracts currently)
+- Citation graph traversal (OpenAlex has data but we don't use it)
+- Query optimization (basic synonym expansion, no MeSH term mapping)
+
+---
+
+## Tool 1: PubMed (NCBI E-utilities)
+
+**File**: `src/tools/pubmed.py`
+
+### What It Does Well
+| Feature | Status | Notes |
+|---------|--------|-------|
+| Rate limiting | ✅ | Shared limiter, respects 3/sec (no key) or 10/sec (with key) |
+| Retry logic | ✅ | tenacity with exponential backoff |
+| Query preprocessing | ✅ | Strips question words, expands synonyms |
+| Abstract parsing | ✅ | Handles XML edge cases (dict vs list) |
+
+### Limitations (API-Level)
+| Limitation | Severity | Workaround Possible? |
+|------------|----------|---------------------|
+| **10,000 result cap per query** | Medium | Yes - use date ranges to paginate |
+| **Abstracts only** (no full text) | High | No - full text requires PMC or publisher |
+| **No citation counts** | Medium | Yes - cross-reference with OpenAlex |
+| **Rate limit (10/sec max)** | Low | Already handled |
+
+### Current Implementation Gaps
+```python
+# GAP 1: No MeSH term expansion
+# Current: expand_synonyms() uses hardcoded dict
+# Better: Use NCBI's E-utilities to get MeSH terms for query
+
+# GAP 2: No date filtering
+# Current: Gets whatever PubMed returns (biased toward recent)
+# Better: Add date range parameter for historical research
+
+# GAP 3: No publication type filtering
+# Current: Returns all types (reviews, case reports, RCTs)
+# Better: Filter for RCTs and systematic reviews when appropriate
+```
+
+### Priority Improvements
+1. **HIGH**: Add publication type filter (Reviews, RCTs, Meta-analyses)
+2. **MEDIUM**: Add date range parameter
+3. **LOW**: MeSH term expansion via E-utilities
+
+---
+
+## Tool 2: ClinicalTrials.gov
+
+**File**: `src/tools/clinicaltrials.py`
+
+### What It Does Well
+| Feature | Status | Notes |
+|---------|--------|-------|
+| API v2 usage | ✅ | Modern API, not deprecated v1 |
+| Interventional filter | ✅ | Only gets drug/treatment studies |
+| Status filter | ✅ | COMPLETED, ACTIVE, RECRUITING |
+| httpx → requests workaround | ✅ | Bypasses WAF TLS fingerprint block |
+
+### Limitations (API-Level)
+| Limitation | Severity | Workaround Possible? |
+|------------|----------|---------------------|
+| **No results data** | High | Yes - available via different endpoint |
+| **No outcome measures** | High | Yes - add to FIELDS list |
+| **No adverse events** | Medium | Yes - separate API call |
+| **Sparse drug mechanism data** | Medium | No - not in API |
+
+### Current Implementation Gaps
+```python
+# GAP 1: Missing critical fields
+FIELDS: ClassVar[list[str]] = [
+    "NCTId",
+    "BriefTitle",
+    "Phase",
+    "OverallStatus",
+    "Condition",
+    "InterventionName",
+    "StartDate",
+    "BriefSummary",
+    # MISSING:
+    # "PrimaryOutcome",
+    # "SecondaryOutcome",
+    # "ResultsFirstSubmitDate",
+    # "StudyResults",  # Whether results are posted
+]
+
+# GAP 2: No results retrieval
+# Many completed trials have posted results
+# We could get actual efficacy data, not just trial existence
+
+# GAP 3: No linked publications
+# Trials often link to PubMed articles with results
+# We could follow these links for richer evidence
+```
+
+### Priority Improvements
+1. **HIGH**: Add outcome measures to FIELDS
+2. **HIGH**: Check for and retrieve posted results
+3. **MEDIUM**: Follow linked publications (NCT → PMID)
+
+---
+
+## Tool 3: Europe PMC
+
+**File**: `src/tools/europepmc.py`
+
+### What It Does Well
+| Feature | Status | Notes |
+|---------|--------|-------|
+| Preprint coverage | ✅ | bioRxiv, medRxiv, ChemRxiv indexed |
+| Preprint labeling | ✅ | `[PREPRINT - Not peer-reviewed]` marker |
+| DOI/PMID fallback URLs | ✅ | Smart URL construction |
+| Relevance scoring | ✅ | Preprints weighted lower (0.75 vs 0.9) |
+
+### Limitations (API-Level)
+| Limitation | Severity | Workaround Possible? |
+|------------|----------|---------------------|
+| **No full text for most articles** | High | Partial - CC-licensed available after 14 days |
+| **Citation data limited** | Medium | Only journal articles, not preprints |
+| **Preprint-publication linking gaps** | Medium | ~50% of links missing per Crossref |
+| **License info sometimes missing** | Low | Manual review required |
+
+### Current Implementation Gaps
+```python
+# GAP 1: No full-text retrieval
+# Europe PMC has full text for many CC-licensed articles
+# Could retrieve full text XML via separate endpoint
+
+# GAP 2: Massive overlap with PubMed
+# Europe PMC indexes all of PubMed/MEDLINE
+# We're getting duplicates with no deduplication
+
+# GAP 3: No citation network
+# Europe PMC has "citedByCount" but we don't use it
+# Could prioritize highly-cited preprints
+```
+
+### Priority Improvements
+1. **HIGH**: Add deduplication with PubMed (by PMID)
+2. **MEDIUM**: Retrieve citation counts for ranking
+3. **LOW**: Full-text retrieval for CC-licensed articles
+
+---
+
+## Tool 4: OpenAlex
+
+**File**: `src/tools/openalex.py`
+
+### What It Does Well
+| Feature | Status | Notes |
+|---------|--------|-------|
+| Citation counts | ✅ | Sorted by `cited_by_count:desc` |
+| Abstract reconstruction | ✅ | Handles inverted index format |
+| Concept extraction | ✅ | Hierarchical classification |
+| Open access detection | ✅ | `is_oa` and `pdf_url` |
+| Polite pool | ✅ | mailto for 100k/day limit |
+| Rich metadata | ✅ | Best metadata of all tools |
+
+### Limitations (API-Level)
+| Limitation | Severity | Workaround Possible? |
+|------------|----------|---------------------|
+| **Author truncation at 100** | Low | Only affects mega-author papers |
+| **No full text** | High | No - OpenAlex is metadata only |
+| **Stale data (1-2 day lag)** | Low | Acceptable for research |
+
+### Current Implementation Gaps
+```python
+# GAP 1: No citation graph traversal
+# OpenAlex has `cited_by` and `references` endpoints
+# We could find seminal papers by following citation chains
+
+# GAP 2: No related works
+# OpenAlex has ML-powered "related_works" field
+# Could expand search to similar papers
+
+# GAP 3: No concept filtering
+# OpenAlex has hierarchical concepts
+# Could filter for specific domains (e.g., "Sexual health" concept)
+
+# GAP 4: Overlap with PubMed
+# OpenAlex indexes most of PubMed
+# More duplicates without deduplication
+```
+
+### Priority Improvements
+1. **HIGH**: Add citation graph traversal (find seminal papers)
+2. **HIGH**: Add deduplication with PubMed/Europe PMC
+3. **MEDIUM**: Use `related_works` for query expansion
+4. **LOW**: Concept-based filtering
+
+---
+
+## Cross-Tool Issues
+
+### Issue 1: MASSIVE DUPLICATION
+
+```
+PubMed: 36M+ articles
+Europe PMC: Indexes ALL of PubMed + preprints
+OpenAlex: 250M+ works (includes PubMed)
+
+Current behavior: All 3 return the same papers
+Result: Duplicate evidence, wasted tokens, inflated counts
+```
+
+**Solution**: Deduplication by PMID/DOI
+```python
+# Proposed: Add to SearchHandler
+def deduplicate_evidence(evidence_list: list[Evidence]) -> list[Evidence]:
+    seen_ids: set[str] = set()
+    unique: list[Evidence] = []
+    for e in evidence_list:
+        # Extract PMID or DOI from URL
+        paper_id = extract_paper_id(e.citation.url)
+        if paper_id not in seen_ids:
+            seen_ids.add(paper_id)
+            unique.append(e)
+    return unique
+```
+
+### Issue 2: NO FULL-TEXT RETRIEVAL
+
+All tools return **abstracts only**. For deep research, this is limiting.
+
+**What's Actually Possible**:
+| Source | Full Text Access | How |
+|--------|------------------|-----|
+| PubMed Central (PMC) | Yes, for OA articles | Separate API: `efetch` with `db=pmc` |
+| Europe PMC | Yes, CC-licensed after 14 days | `/fullTextXML/{id}` endpoint |
+| OpenAlex | No | Metadata only |
+| Unpaywall | Yes, OA link discovery | Separate API |
+
+**Recommendation**: Add PMC full-text retrieval for open access articles.
+
+### Issue 3: NO CITATION GRAPH
+
+OpenAlex has rich citation data but we only use `cited_by_count` for sorting.
+
+**Untapped Capabilities**:
+- `cited_by`: Find papers that cite a key paper
+- `references`: Find sources a paper cites
+- `related_works`: ML-powered similar papers
+
+**Use Case**: User asks about "testosterone therapy for HSDD". We find a seminal 2019 RCT. We could automatically find:
+- Papers that cite it (newer evidence)
+- Papers it cites (foundational research)
+- Related papers (similar topics)
+
+---
+
+## What's NOT Possible (API Constraints)
+
+| Feature | Why Not Possible |
+|---------|------------------|
+| **bioRxiv direct search** | No keyword search API, only RSS feed of latest |
+| **arXiv search** | API exists but irrelevant for sexual health |
+| **PubMed full text** | Requires publisher access or PMC |
+| **Real-time trial results** | ClinicalTrials.gov results are static snapshots |
+| **Drug mechanism data** | Not in any API - would need ChEMBL or DrugBank |
+
+---
+
+## Recommended Improvements (Priority Order)
+
+### Phase 1: Fix Fundamentals (High ROI)
+1. **Deduplication** - Stop returning the same paper 3 times
+2. **Outcome measures in ClinicalTrials** - Get actual efficacy data
+3. **Citation counts from all sources** - Rank by influence, not recency
+
+### Phase 2: Depth Improvements (Medium ROI)
+4. **PMC full-text retrieval** - Get full papers for OA articles
+5. **Citation graph traversal** - Find seminal papers automatically
+6. **Publication type filtering** - Prioritize RCTs and meta-analyses
+
+### Phase 3: Quality Improvements (Lower ROI, Nice-to-Have)
+7. **MeSH term expansion** - Better PubMed queries
+8. **Related works expansion** - Use OpenAlex ML similarity
+9. **Date range filtering** - Historical vs recent research
+
+---
+
+## Neo4j Integration (Future Consideration)
+
+**Question**: Should we add Neo4j for citation graph storage?
+
+**Answer**: Not yet. Here's why:
+
+| Approach | Complexity | Value |
+|----------|------------|-------|
+| OpenAlex API for citation traversal | Low | High |
+| Neo4j for local citation graph | High | Medium (unless doing graph analytics) |
+| Cron job to sync OpenAlex → Neo4j | Medium | Only if we need offline access |
+
+**Recommendation**: Use OpenAlex API for citation traversal first. Only add Neo4j if:
+1. We need to do complex graph queries (PageRank on citations, community detection)
+2. We need offline access to citation data
+3. We're hitting OpenAlex rate limits
+
+---
+
+## Summary: What's Broken vs What's Working
+
+### Working Well
+- Basic search across all 4 sources
+- Rate limiting and retry logic
+- Query preprocessing
+- Evidence model with citations
+
+### Needs Fixing (Current Scope)
+- Deduplication (critical)
+- Outcome measures in ClinicalTrials (critical)
+- Citation-based ranking (important)
+
+### Future Enhancements (Out of Current Scope)
+- Full-text retrieval
+- Citation graph traversal
+- Neo4j integration
+- Drug mechanism data (would need new data sources)
+
+---
+
+## Sources
+
+- [NCBI E-utilities Documentation](https://www.ncbi.nlm.nih.gov/books/NBK25497/)
+- [NCBI Rate Limits](https://ncbiinsights.ncbi.nlm.nih.gov/2017/11/02/new-api-keys-for-the-e-utilities/)
+- [OpenAlex API Docs](https://docs.openalex.org/)
+- [OpenAlex Limitations](https://docs.openalex.org/api-entities/authors/limitations)
+- [Europe PMC RESTful API](https://europepmc.org/RestfulWebService)
+- [Europe PMC Preprints](https://pmc.ncbi.nlm.nih.gov/articles/PMC11426508/)
+- [ClinicalTrials.gov API](https://clinicaltrials.gov/data-api/api)

docs/specs/SPEC_11_SEXUAL_HEALTH_FOCUS.md

@@ -1,178 +1,61 @@
-# SPEC_11: Narrow Scope to Sexual Health Only
-
-## Problem Statement
-
-DeepBoner has an **identity crisis**. Despite being branded as a "pro-sexual deep research agent" (the name is literally "DeepBoner"), the codebase currently supports three domains:
-
-1. **GENERAL** - Generic research (default!)
-2. **DRUG_REPURPOSING** - Drug repurposing research
-3. **SEXUAL_HEALTH** - Sexual health research
-
-This happened because Issue #75 recommended "general purpose with domain presets", but that was the **wrong decision** for this project's identity.
-
-### Evidence of the Problem
-
-**Current examples in Gradio UI:**
-```python
-examples=[
-    ["What drugs improve female libido post-menopause?", "simple", "sexual_health", ...],
-    ["Metformin mechanism for Alzheimer's?", "simple", "general", ...],  # <-- NOT SEXUAL HEALTH!
-    ["Clinical trials for PDE5 inhibitors alternatives?", "advanced", "sexual_health", ...],
-]
-```
-
-**Default domain is "general":**
-```python
-value="general",  # <-- WRONG! Should be sexual_health
-```
-
-## The Decision
-
-**DeepBoner IS a Sexual Health Research Specialist (Option B from Issue #75)**
-
-Reasons:
-1. **Brand identity**: "DeepBoner" is unmistakably sexual health themed
-2. **Hackathon differentiation**: A focused niche beats generic competition
-3. **Prompt quality**: Domain-specific prompts are more effective
-4. **Simplicity**: Less code, less confusion
-
-## Implementation Plan
-
-### Phase 1: Simplify Domain Enum
-
-**File: `src/config/domain.py`**
-
-```python
-# BEFORE
-class ResearchDomain(str, Enum):
-    GENERAL = "general"
-    DRUG_REPURPOSING = "drug_repurposing"
-    SEXUAL_HEALTH = "sexual_health"
-
-DEFAULT_DOMAIN = ResearchDomain.GENERAL
-
-# AFTER
-class ResearchDomain(str, Enum):
-    SEXUAL_HEALTH = "sexual_health"
-
-DEFAULT_DOMAIN = ResearchDomain.SEXUAL_HEALTH
-```
-
-**Also remove:**
-- `GENERAL_CONFIG`
-- `DRUG_REPURPOSING_CONFIG`
-- Their entries in `DOMAIN_CONFIGS`
-
-### Phase 2: Update Gradio Examples
-
-**File: `src/app.py`**
-
-Replace examples with 3 sexual-health-only queries:
-
-```python
-examples=[
-    [
-        "What drugs improve female libido post-menopause?",
-        "simple",
-        "sexual_health",
-        None,
-        None,
-    ],
-    [
-        "Testosterone therapy for hypoactive sexual desire disorder?",
-        "simple",
-        "sexual_health",
-        None,
-        None,
-    ],
-    [
-        "Clinical trials for PDE5 inhibitors alternatives?",
-        "advanced",
-        "sexual_health",
-        None,
-        None,
-    ],
-],
-```
-
-### Phase 3: Simplify or Remove Domain Dropdown
-
-**Option A: Remove dropdown entirely**
-- Remove the `gr.Dropdown` for domain selection
-- Hardcode `domain="sexual_health"` in the function
-
-**Option B: Keep but simplify** (recommended for backwards compat)
-- Only show `["sexual_health"]` in choices
-- Default to `"sexual_health"`
-- Keeps the parameter in case we want to add domains later
-
-```python
-gr.Dropdown(
-    choices=["sexual_health"],  # Only one choice
-    value="sexual_health",
-    label="Research Domain",
-    info="Specialized for sexual health research",
-    visible=False,  # Hide since there's only one option
-),
-```
-
-### Phase 4: Update Tests
-
-Update domain-related tests to only test SEXUAL_HEALTH:
-
-```python
-# BEFORE
-def test_get_domain_config_general():
-    config = get_domain_config(ResearchDomain.GENERAL)
-    assert config.name == "General Research"
-
-# AFTER
-def test_get_domain_config_default():
-    config = get_domain_config()
-    assert config.name == "Sexual Health Research"
-```
-
-### Phase 5: Update Documentation
-
-- `CLAUDE.md`: Update description to focus on sexual health
-- `README.md`: Update if needed
-- Remove references to "drug repurposing" or "general" modes
-
-## Files to Modify
-
-| File | Changes |
-|------|---------|
-| `src/config/domain.py` | Remove GENERAL, DRUG_REPURPOSING; change DEFAULT_DOMAIN |
-| `src/app.py` | Update examples; simplify/hide domain dropdown |
-| `src/utils/config.py` | Change default `research_domain` field |
-| `tests/unit/config/test_domain.py` | Update to test only SEXUAL_HEALTH |
-| `tests/unit/utils/test_config_domain.py` | Update enum tests |
-| `tests/unit/test_app_domain.py` | Update to use SEXUAL_HEALTH |
-| `CLAUDE.md` | Update project description |
-
-## Example Queries (All Sexual Health)
-
-1. **Female libido**: "What drugs improve female libido post-menopause?"
-2. **Low desire**: "Testosterone therapy for hypoactive sexual desire disorder?"
-3. **ED alternatives**: "Clinical trials for PDE5 inhibitors alternatives?"
-
-Alternative options:
-- "Flibanserin mechanism of action and efficacy?"
-- "Bremelanotide for hypoactive sexual desire disorder?"
-- "PT-141 clinical trial results?"
-- "Natural supplements for erectile dysfunction?"
-
-## Success Criteria
-
-- [ ] Only `SEXUAL_HEALTH` domain exists in enum
-- [ ] Default domain is `SEXUAL_HEALTH`
-- [ ] All 3 Gradio examples are sexual health queries
-- [ ] Domain dropdown is hidden or removed
-- [ ] All tests pass with 227+ tests
-- [ ] No references to "Metformin for Alzheimer's" or "general" domain
-
-## Related Issues
-
-- #75 (CLOSED) - Domain Identity Crisis (original issue, wrong recommendation)
-- #76 (CLOSED) - Hardcoded prompts (implemented but too general)
-- #85 (OPEN) - Report lacks narrative synthesis (next priority)
+# SPEC_11: Sexual Health Research Specialist (Final Polish)
+
+**Status**: APPROVED
+**Priority**: P0 (Critical Fix)
+**Effort**: Low (Cleanup & Polish)
+**Related Issues**: #75, #89
+
+## 1. Executive Summary
+
+DeepBoner is **exclusively** a Sexual Health Research Agent. The codebase is currently in a transitional state where "General" and "Drug Repurposing" modes were architecturally removed, but significant artifacts (docstrings, default arguments, variable names, and examples) remain.
+
+This specification dictates the **complete eradication** of non-sexual-health concepts from the codebase to ensure a consistent, focused, and professional product identity.
+
+## 2. The Rules of Engagement
+
+1.  **No "General" Defaults**: The string literal `"general"` shall not exist as a default value for any `domain` parameter.
+2.  **No "Drug Repurposing" References**: Terms like "metformin", "alzheimer", "cancer", "aspirin" in examples must be replaced with sexual health examples.
+3.  **Single Source of Truth**: `src.config.domain.ResearchDomain.SEXUAL_HEALTH` is the *only* valid domain.
+4.  **Ironclad Tests**: Tests must use sexual health queries (e.g., "libido", "testosterone", "PDE5") to ensure the domain logic is actually exercising the production paths.
+
+## 3. Implementation Plan
+
+### 3.1. Code Cleanup (`src/`)
+
+#### `src/app.py`
+- **Logic Fix**: Change `domain_str = domain or "general"` to `domain_str = domain or "sexual_health"`.
+- **Signature Fix**: Change `domain: str = "general"` to `domain: str = "sexual_health"`.
+- **Docstring Fix**: Remove `(e.g., "general", "sexual_health")`.
+
+#### `src/mcp_tools.py`
+- **Signature Fix**: Update `search_pubmed` and `search_all_sources` to default `domain="sexual_health"`.
+- **Docstring Fix**: Update examples from "metformin alzheimer" to "testosterone libido".
+- **Argument Description**: Remove `(general, drug_repurposing, sexual_health)` list.
+
+#### `src/tools/*.py`
+- **`clinicaltrials.py`, `query_utils.py`, `tools.py`**: Replace all "metformin/alzheimer" example strings with sexual health examples.
+
+#### `src/config/domain.py`
+- **Comment Fix**: Remove `# Get default (general) config`.
+
+### 3.2. Test Suite Alignment (`tests/`)
+
+#### `tests/unit/agent_factory/test_judges.py`
+- Replace `metformin alzheimer` test queries with `sildenafil efficacy`.
+
+#### `tests/unit/tools/test_query_utils.py`
+- Ensure synonym expansion tests use relevant terms (or generic ones that don't imply a different domain).
+
+#### `tests/unit/mcp/test_mcp_tools_domain.py`
+- Verify defaults are "sexual_health", not "general".
+
+## 4. Verification Checklist
+
+- [ ] **Grep Audit**: `grep -r "general" src/` should return zero results where it refers to a domain default.
+- [ ] **Grep Audit**: `grep -r "metformin" src/` should return zero results.
+- [ ] **Functionality**: `src/app.py` runs without crashing when `domain` is `None` (defaults to sexual_health).
+- [ ] **Tests**: All 237+ tests pass.
+
+## 5. Success State
+
+When this spec is implemented, a developer reading the code should see **zero evidence** that this agent was ever intended for anything other than Sexual Health research.

examples/README.md

@@ -2,7 +2,7 @@
 
 **NO MOCKS. NO FAKE DATA. REAL SCIENCE.**
 
-These demos run the REAL drug repurposing research pipeline with actual API calls.
+These demos run the REAL sexual health research pipeline with actual API calls.
 
 ---
 
@@ -31,7 +31,7 @@ NCBI_API_KEY=your-key
 Demonstrates REAL parallel search across PubMed, ClinicalTrials.gov, and Europe PMC.
 
 ```bash
-uv run python examples/search_demo/run_search.py "metformin cancer"
+uv run python examples/search_demo/run_search.py "testosterone libido"
 ```
 
 **What's REAL:**
@@ -63,8 +63,8 @@ uv run python examples/embeddings_demo/run_embeddings.py
 Demonstrates the REAL search-judge-synthesize loop.
 
 ```bash
-uv run python examples/orchestrator_demo/run_agent.py "metformin cancer"
-uv run python examples/orchestrator_demo/run_agent.py "aspirin alzheimer" --iterations 5
+uv run python examples/orchestrator_demo/run_agent.py "testosterone libido"
+uv run python examples/orchestrator_demo/run_agent.py "sildenafil erectile dysfunction" --iterations 5
 ```
 
 **What's REAL:**
@@ -81,7 +81,7 @@ Demonstrates REAL multi-agent coordination using Microsoft Agent Framework.
 
 ```bash
 # Requires OPENAI_API_KEY specifically
-uv run python examples/orchestrator_demo/run_magentic.py "metformin cancer"
+uv run python examples/orchestrator_demo/run_magentic.py "testosterone libido"
 ```
 
 **What's REAL:**
@@ -96,8 +96,8 @@ uv run python examples/orchestrator_demo/run_magentic.py "metformin cancer"
 Demonstrates REAL mechanistic hypothesis generation.
 
 ```bash
-uv run python examples/hypothesis_demo/run_hypothesis.py "metformin Alzheimer's"
-uv run python examples/hypothesis_demo/run_hypothesis.py "sildenafil heart failure"
+uv run python examples/hypothesis_demo/run_hypothesis.py "testosterone libido"
+uv run python examples/hypothesis_demo/run_hypothesis.py "sildenafil erectile dysfunction"
 ```
 
 **What's REAL:**
@@ -113,8 +113,8 @@ uv run python examples/hypothesis_demo/run_hypothesis.py "sildenafil heart failu
 **THE COMPLETE PIPELINE** - All phases working together.
 
 ```bash
-uv run python examples/full_stack_demo/run_full.py "metformin Alzheimer's"
-uv run python examples/full_stack_demo/run_full.py "sildenafil heart failure" -i 3
+uv run python examples/full_stack_demo/run_full.py "testosterone libido"
+uv run python examples/full_stack_demo/run_full.py "sildenafil erectile dysfunction" -i 3
 ```
 
 **What's REAL:**
@@ -181,4 +181,4 @@ Mocks belong in `tests/unit/`, not in demos. When you run these examples, you se
 - Real scientific hypotheses
 - Real research reports
 
-This is what DeepBoner actually does. No fake data. No canned responses.
+This is what DeepBoner actually does. No fake data. No canned responses.

examples/embeddings_demo/run_embeddings.py

@@ -39,7 +39,7 @@ async def demo_real_pipeline() -> None:
     print("=" * 60)
 
     # 1. Fetch Real Data
-    query = "metformin mechanism of action"
+    query = "testosterone mechanism of action"
     print(f"\n[1] Fetching real papers for: '{query}'...")
     pubmed = PubMedTool()
     # Fetch enough results to likely get some overlap/redundancy

examples/full_stack_demo/run_full.py

@@ -2,7 +2,7 @@
 """
 Demo: Full Stack DeepBoner Agent (Phases 1-8).
 
-This script demonstrates the COMPLETE REAL drug repurposing research pipeline:
+This script demonstrates the COMPLETE REAL sexual health research pipeline:
 - Phase 2: REAL Search (PubMed + ClinicalTrials + Europe PMC)
 - Phase 6: REAL Embeddings (sentence-transformers + ChromaDB)
 - Phase 7: REAL Hypothesis (LLM mechanistic reasoning)
@@ -12,8 +12,8 @@ This script demonstrates the COMPLETE REAL drug repurposing research pipeline:
 NO MOCKS. NO FAKE DATA. REAL SCIENCE.
 
 Usage:
-    uv run python examples/full_stack_demo/run_full.py "metformin Alzheimer's"
-    uv run python examples/full_stack_demo/run_full.py "sildenafil heart failure" -i 3
+    uv run python examples/full_stack_demo/run_full.py "testosterone libido"
+    uv run python examples/full_stack_demo/run_full.py "sildenafil erectile dysfunction" -i 3
 
 Requires: OPENAI_API_KEY or ANTHROPIC_API_KEY
 """
@@ -183,14 +183,14 @@ This demo runs the COMPLETE pipeline with REAL API calls:
   5. REAL report: Actual LLM generating structured report
 
 Examples:
-    uv run python examples/full_stack_demo/run_full.py "metformin Alzheimer's"
-    uv run python examples/full_stack_demo/run_full.py "sildenafil heart failure" -i 3
-    uv run python examples/full_stack_demo/run_full.py "aspirin cancer prevention"
+    uv run python examples/full_stack_demo/run_full.py "testosterone libido"
+    uv run python examples/full_stack_demo/run_full.py "sildenafil erectile dysfunction" -i 3
+    uv run python examples/full_stack_demo/run_full.py "flibanserin mechanism"
         """,
     )
     parser.add_argument(
         "query",
-        help="Research query (e.g., 'metformin Alzheimer's disease')",
+        help="Research query (e.g., 'testosterone libido')",
     )
     parser.add_argument(
         "-i",

examples/hypothesis_demo/run_hypothesis.py

@@ -9,8 +9,8 @@ This script demonstrates the REAL hypothesis generation pipeline:
 
 Usage:
     # Requires OPENAI_API_KEY or ANTHROPIC_API_KEY
-    uv run python examples/hypothesis_demo/run_hypothesis.py "metformin Alzheimer's"
-    uv run python examples/hypothesis_demo/run_hypothesis.py "sildenafil heart failure"
+    uv run python examples/hypothesis_demo/run_hypothesis.py "testosterone libido"
+    uv run python examples/hypothesis_demo/run_hypothesis.py "sildenafil erectile dysfunction"
 """
 
 import argparse
@@ -102,15 +102,15 @@ async def main() -> None:
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
-    uv run python examples/hypothesis_demo/run_hypothesis.py "metformin Alzheimer's"
-    uv run python examples/hypothesis_demo/run_hypothesis.py "sildenafil heart failure"
-    uv run python examples/hypothesis_demo/run_hypothesis.py "aspirin cancer prevention"
+    uv run python examples/hypothesis_demo/run_hypothesis.py "testosterone libido"
+    uv run python examples/hypothesis_demo/run_hypothesis.py "sildenafil erectile dysfunction"
+    uv run python examples/hypothesis_demo/run_hypothesis.py "flibanserin mechanism"
         """,
     )
     parser.add_argument(
         "query",
         nargs="?",
-        default="metformin Alzheimer's disease",
+        default="testosterone libido",
         help="Research query",
     )
     args = parser.parse_args()

examples/modal_demo/run_analysis.py

@@ -3,8 +3,9 @@
 
 This script uses StatisticalAnalyzer directly (NO agent_framework dependency).
 
-Usage:
-    uv run python examples/modal_demo/run_analysis.py "metformin alzheimer"
+# Usage:
+#   source .env
+#   uv run python examples/modal_demo/run_analysis.py "testosterone libido"
 """
 
 import argparse

examples/orchestrator_demo/run_agent.py

@@ -11,8 +11,9 @@ This script demonstrates the REAL Phase 4 orchestration:
 NO MOCKS. REAL API CALLS.
 
 Usage:
-    uv run python examples/orchestrator_demo/run_agent.py "metformin cancer"
-    uv run python examples/orchestrator_demo/run_agent.py "sildenafil heart failure" --iterations 5
+    uv run python examples/orchestrator_demo/run_agent.py "testosterone libido"
+    uv run python examples/orchestrator_demo/run_agent.py "sildenafil erectile dysfunction" \
+        --iterations 5
 
 Requires: OPENAI_API_KEY or ANTHROPIC_API_KEY
 """
@@ -46,11 +47,11 @@ This demo runs the REAL search-judge-synthesize loop:
   4. REAL synthesis: Actual research summary generation
 
 Examples:
-    uv run python examples/orchestrator_demo/run_agent.py "metformin cancer"
-    uv run python examples/orchestrator_demo/run_agent.py "aspirin alzheimer" --iterations 5
+    uv run python examples/orchestrator_demo/run_agent.py "testosterone libido"
+    uv run python examples/orchestrator_demo/run_agent.py "flibanserin HSDD" --iterations 5
         """,
     )
-    parser.add_argument("query", help="Research query (e.g., 'metformin cancer')")
+    parser.add_argument("query", help="Research query (e.g., 'testosterone libido')")
     parser.add_argument("--iterations", type=int, default=3, help="Max iterations (default: 3)")
     args = parser.parse_args()
 

examples/orchestrator_demo/run_magentic.py

@@ -8,7 +8,7 @@ This script demonstrates Phase 5 functionality:
 
 Usage:
     export OPENAI_API_KEY=...
-    uv run python examples/orchestrator_demo/run_magentic.py "metformin cancer"
+    uv run python examples/orchestrator_demo/run_magentic.py "testosterone libido"
 """
 
 import argparse
@@ -28,7 +28,7 @@ from src.utils.models import OrchestratorConfig
 async def main() -> None:
     """Run the magentic agent demo."""
     parser = argparse.ArgumentParser(description="Run DeepBoner Magentic Agent")
-    parser.add_argument("query", help="Research query (e.g., 'metformin cancer')")
+    parser.add_argument("query", help="Research query (e.g., 'testosterone libido')")
     parser.add_argument("--iterations", type=int, default=10, help="Max rounds")
     args = parser.parse_args()
 

examples/search_demo/run_search.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Demo: Search for drug repurposing evidence.
+Demo: Search for sexual health research evidence.
 
 This script demonstrates multi-source search functionality:
 - PubMed search (biomedical literature)
@@ -12,7 +12,7 @@ Usage:
     uv run python examples/search_demo/run_search.py
 
     # With custom query:
-    uv run python examples/search_demo/run_search.py "metformin cancer"
+    uv run python examples/search_demo/run_search.py "testosterone libido"
 
 Requirements:
     - Optional: NCBI_API_KEY in .env for higher PubMed rate limits
@@ -61,7 +61,7 @@ async def main(query: str) -> None:
 
 if __name__ == "__main__":
     # Default query or use command line arg
-    default_query = "metformin Alzheimer's disease drug repurposing"
+    default_query = "testosterone post-menopause libido"
     query = sys.argv[1] if len(sys.argv) > 1 else default_query
 
     asyncio.run(main(query))

src/agent_factory/judges.py

@@ -166,7 +166,13 @@ class JudgeHandler:
             return assessment
 
         except Exception as e:
-            logger.error("Assessment failed", error=str(e))
+            # Log with context for debugging
+            logger.error(
+                "Assessment failed",
+                error=str(e),
+                exc_type=type(e).__name__,
+                evidence_count=len(evidence),
+            )
             # Return a safe default assessment on failure
             return self._create_fallback_assessment(question, str(e))
 

src/agents/magentic_agents.py

@@ -133,7 +133,7 @@ Based on evidence:
    DRUG -> TARGET -> PATHWAY -> THERAPEUTIC EFFECT
 
    Example:
-   Metformin -> AMPK activation -> mTOR inhibition -> Reduced tau phosphorylation
+   Testosterone -> Androgen receptor -> Dopamine modulation -> Enhanced libido
 
 4. Explain the rationale for each hypothesis
 5. Suggest what additional evidence would support or refute it

src/agents/tools.py

@@ -25,7 +25,7 @@ async def search_pubmed(query: str, max_results: int = 10) -> str:
     drugs, diseases, mechanisms of action, and clinical studies.
 
     Args:
-        query: Search keywords (e.g., "metformin alzheimer mechanism")
+        query: Search keywords (e.g., "testosterone libido mechanism")
         max_results: Maximum results to return (default 10)
 
     Returns:
@@ -85,7 +85,7 @@ async def search_clinical_trials(query: str, max_results: int = 10) -> str:
     for potential interventions.
 
     Args:
-        query: Search terms (e.g., "metformin cancer phase 3")
+        query: Search terms (e.g., "sildenafil phase 3")
         max_results: Maximum results to return (default 10)
 
     Returns:
@@ -125,7 +125,7 @@ async def search_preprints(query: str, max_results: int = 10) -> str:
     from bioRxiv, medRxiv, and peer-reviewed papers.
 
     Args:
-        query: Search terms (e.g., "long covid treatment")
+        query: Search terms (e.g., "flibanserin HSDD preprint")
         max_results: Maximum results to return (default 10)
 
     Returns:

src/app.py

@@ -2,7 +2,7 @@
 
 import os
 from collections.abc import AsyncGenerator
-from typing import Any
+from typing import Any, Literal
 
 import gradio as gr
 from pydantic_ai.models.anthropic import AnthropicModel
@@ -22,10 +22,12 @@ from src.utils.config import settings
 from src.utils.exceptions import ConfigurationError
 from src.utils.models import OrchestratorConfig
 
+OrchestratorMode = Literal["simple", "magentic", "advanced", "hierarchical"]
+
 
 def configure_orchestrator(
     use_mock: bool = False,
-    mode: str = "simple",
+    mode: OrchestratorMode = "simple",
     user_api_key: str | None = None,
     domain: str | ResearchDomain | None = None,
 ) -> tuple[Any, str]:
@@ -36,7 +38,7 @@ def configure_orchestrator(
         use_mock: If True, use MockJudgeHandler (no API key needed)
         mode: Orchestrator mode ("simple" or "advanced")
         user_api_key: Optional user-provided API key (BYOK) - auto-detects provider
-        domain: Research domain (e.g., "general", "sexual_health")
+        domain: Research domain (defaults to "sexual_health")
 
     Returns:
         Tuple of (Orchestrator instance, backend_name)
@@ -100,7 +102,7 @@ def configure_orchestrator(
         search_handler=search_handler,
         judge_handler=judge_handler,
         config=config,
-        mode=mode,  # type: ignore
+        mode=mode,
         api_key=user_api_key,
         domain=domain,
     )
@@ -111,8 +113,8 @@ def configure_orchestrator(
 async def research_agent(
     message: str,
     history: list[dict[str, Any]],
-    mode: str = "simple",
-    domain: str = "general",
+    mode: str = "simple",  # Gradio passes strings; validated below
+    domain: str = "sexual_health",
     api_key: str = "",
     api_key_state: str = "",
 ) -> AsyncGenerator[str, None]:
@@ -138,7 +140,11 @@ async def research_agent(
     # Gradio passes None for missing example columns, overriding defaults
     api_key_str = api_key or ""
     api_key_state_str = api_key_state or ""
-    domain_str = domain or "general"
+    domain_str = domain or "sexual_health"
+
+    # Validate and cast mode to proper type
+    valid_modes: set[str] = {"simple", "magentic", "advanced", "hierarchical"}
+    mode_validated: OrchestratorMode = mode if mode in valid_modes else "simple"  # type: ignore[assignment]
 
     # BUG FIX: Prefer freshly-entered key, then persisted state
     user_api_key = (api_key_str.strip() or api_key_state_str.strip()) or None
@@ -153,12 +159,12 @@ async def research_agent(
     has_paid_key = has_openai or has_anthropic or bool(user_api_key)
 
     # Advanced mode requires OpenAI specifically (due to agent-framework binding)
-    if mode == "advanced" and not (has_openai or is_openai_user_key):
+    if mode_validated == "advanced" and not (has_openai or is_openai_user_key):
         yield (
             "⚠️ **Warning**: Advanced mode currently requires OpenAI API key. "
             "Anthropic keys only work in Simple mode. Falling back to Simple.\n\n"
         )
-        mode = "simple"
+        mode_validated = "simple"
 
     # Inform user about fallback if no keys
     if not has_paid_key:
@@ -177,14 +183,16 @@ async def research_agent(
         # It will use: Paid API > HF Inference (free tier)
         orchestrator, backend_name = configure_orchestrator(
             use_mock=False,  # Never use mock in production - HF Inference is the free fallback
-            mode=mode,
+            mode=mode_validated,
             user_api_key=user_api_key,
             domain=domain_str,
         )
 
         # Immediate backend info + loading feedback so user knows something is happening
+        # Use replace to get "Sexual Health" instead of "Sexual_Health" from .title()
+        domain_display = domain_str.replace("_", " ").title()
         yield (
-            f"🧠 **Backend**: {backend_name} | **Domain**: {domain_str.title()}\n\n"
+            f"🧠 **Backend**: {backend_name} | **Domain**: {domain_display}\n\n"
             "⏳ **Processing...** Searching PubMed, ClinicalTrials.gov, Europe PMC, OpenAlex...\n"
         )
 

src/config/domain.py

@@ -6,7 +6,7 @@ allowing the agent to operate in domain-agnostic or domain-specific modes.
 Usage:
     from src.config.domain import get_domain_config, ResearchDomain
 
-    # Get default (general) config
+    # Get default config
     config = get_domain_config()
 
     # Get specific domain
@@ -111,7 +111,7 @@ def get_domain_config(domain: ResearchDomain | str | None = None) -> DomainConfi
     """Get configuration for a research domain.
 
     Args:
-        domain: The research domain. Defaults to GENERAL if None.
+        domain: The research domain. Defaults to sexual_health if None.
 
     Returns:
         DomainConfig for the specified domain.

src/mcp_tools.py

@@ -18,16 +18,16 @@ _trials = ClinicalTrialsTool()
 _europepmc = EuropePMCTool()
 
 
-async def search_pubmed(query: str, max_results: int = 10, domain: str = "general") -> str:
+async def search_pubmed(query: str, max_results: int = 10, domain: str = "sexual_health") -> str:
     """Search PubMed for peer-reviewed biomedical literature.
 
     Searches NCBI PubMed database for scientific papers matching your query.
     Returns titles, authors, abstracts, and citation information.
 
     Args:
-        query: Search query (e.g., "metformin alzheimer")
+        query: Search query (e.g., "testosterone libido")
         max_results: Maximum results to return (1-50, default 10)
-        domain: Research domain (general, drug_repurposing, sexual_health)
+        domain: Research domain (defaults to "sexual_health")
 
     Returns:
         Formatted search results with paper titles, authors, dates, and abstracts
@@ -58,7 +58,7 @@ async def search_clinical_trials(query: str, max_results: int = 10) -> str:
     Returns trial titles, phases, status, conditions, and interventions.
 
     Args:
-        query: Search query (e.g., "metformin alzheimer", "diabetes phase 3")
+        query: Search query (e.g., "testosterone hypoactive desire", "sildenafil phase 3")
         max_results: Maximum results to return (1-50, default 10)
 
     Returns:
@@ -88,7 +88,7 @@ async def search_europepmc(query: str, max_results: int = 10) -> str:
     Useful for finding cutting-edge preprints and open access papers.
 
     Args:
-        query: Search query (e.g., "metformin neuroprotection", "long covid treatment")
+        query: Search query (e.g., "flibanserin mechanism", "erectile dysfunction novel treatment")
         max_results: Maximum results to return (1-50, default 10)
 
     Returns:
@@ -112,16 +112,18 @@ async def search_europepmc(query: str, max_results: int = 10) -> str:
     return "\n".join(formatted)
 
 
-async def search_all_sources(query: str, max_per_source: int = 5, domain: str = "general") -> str:
+async def search_all_sources(
+    query: str, max_per_source: int = 5, domain: str = "sexual_health"
+) -> str:
     """Search all biomedical sources simultaneously.
 
     Performs parallel search across PubMed, ClinicalTrials.gov, and Europe PMC.
     This is the most comprehensive search option for biomedical research.
 
     Args:
-        query: Search query (e.g., "metformin alzheimer", "aspirin cancer prevention")
+        query: Search query (e.g., "testosterone replacement therapy", "HSDD treatment")
         max_per_source: Maximum results per source (1-20, default 5)
-        domain: Research domain (general, drug_repurposing, sexual_health)
+        domain: Research domain (defaults to "sexual_health")
 
     Returns:
         Combined results from all sources with source labels
@@ -172,8 +174,8 @@ async def analyze_hypothesis(
     the statistical evidence for a research hypothesis.
 
     Args:
-        drug: The drug being evaluated (e.g., "metformin")
-        condition: The target condition (e.g., "Alzheimer's disease")
+        drug: The drug being evaluated (e.g., "sildenafil")
+        condition: The target condition (e.g., "erectile dysfunction")
         evidence_summary: Summary of evidence to analyze
 
     Returns:

src/middleware/sub_iteration.py

@@ -81,12 +81,18 @@ class SubIterationMiddleware:
                 history.append(result)
                 best_result = result  # Assume latest is best for now
             except Exception as e:
-                logger.error("Sub-iteration execution failed", error=str(e))
+                logger.error(
+                    "Sub-iteration execution failed",
+                    error=str(e),
+                    exc_type=type(e).__name__,
+                    iteration=i,
+                )
                 if event_callback:
                     await event_callback(
                         AgentEvent(
                             type="error",
                             message=f"Sub-iteration execution failed: {e}",
+                            data={"recoverable": False, "error_type": type(e).__name__},
                             iteration=i,
                         )
                     )
@@ -97,12 +103,18 @@ class SubIterationMiddleware:
                 assessment = await self.judge.assess(task, result, history)
                 final_assessment = assessment
             except Exception as e:
-                logger.error("Sub-iteration judge failed", error=str(e))
+                logger.error(
+                    "Sub-iteration judge failed",
+                    error=str(e),
+                    exc_type=type(e).__name__,
+                    iteration=i,
+                )
                 if event_callback:
                     await event_callback(
                         AgentEvent(
                             type="error",
                             message=f"Sub-iteration judge failed: {e}",
+                            data={"recoverable": False, "error_type": type(e).__name__},
                             iteration=i,
                         )
                     )

src/orchestrators/factory.py

@@ -75,7 +75,7 @@ def create_orchestrator(
         mode: "simple", "magentic", "advanced", or "hierarchical"
               Note: "magentic" is an alias for "advanced" (kept for backwards compatibility)
         api_key: Optional API key for advanced mode (OpenAI)
-        domain: Research domain for customization (default: General)
+        domain: Research domain for customization (default: sexual_health)
 
     Returns:
         Orchestrator instance implementing OrchestratorProtocol

src/orchestrators/simple.py

@@ -18,7 +18,9 @@ import structlog
 
 from src.config.domain import ResearchDomain, get_domain_config
 from src.orchestrators.base import JudgeHandlerProtocol, SearchHandlerProtocol
+from src.prompts.synthesis import format_synthesis_prompt, get_synthesis_system_prompt
 from src.utils.config import settings
+from src.utils.exceptions import JudgeError, ModalError, SearchError
 from src.utils.models import (
     AgentEvent,
     Evidence,
@@ -132,12 +134,25 @@ class Orchestrator:
                 iteration=iteration,
             )
 
+        except ModalError as e:
+            logger.error("Modal analysis failed", error=str(e), exc_type="ModalError")
+            yield AgentEvent(
+                type="error",
+                message=f"Modal analysis failed: {e}",
+                data={"error": str(e), "recoverable": True},
+                iteration=iteration,
+            )
         except Exception as e:
-            logger.error("Modal analysis failed", error=str(e))
+            # Unexpected error - log with full context for debugging
+            logger.error(
+                "Modal analysis failed unexpectedly",
+                error=str(e),
+                exc_type=type(e).__name__,
+            )
             yield AgentEvent(
                 type="error",
                 message=f"Modal analysis failed: {e}",
-                data={"error": str(e)},
+                data={"error": str(e), "recoverable": True},
                 iteration=iteration,
             )
 
@@ -288,11 +303,26 @@ class Orchestrator:
                 if errors:
                     logger.warning("Search errors", errors=errors)
 
+            except SearchError as e:
+                logger.error("Search phase failed", error=str(e), exc_type="SearchError")
+                yield AgentEvent(
+                    type="error",
+                    message=f"Search failed: {e!s}",
+                    data={"recoverable": True, "error_type": "search"},
+                    iteration=iteration,
+                )
+                continue
             except Exception as e:
-                logger.error("Search phase failed", error=str(e))
+                # Unexpected error - log full context for debugging
+                logger.error(
+                    "Search phase failed unexpectedly",
+                    error=str(e),
+                    exc_type=type(e).__name__,
+                )
                 yield AgentEvent(
                     type="error",
                     message=f"Search failed: {e!s}",
+                    data={"recoverable": True, "error_type": "unexpected"},
                     iteration=iteration,
                 )
                 continue
@@ -388,9 +418,9 @@ class Orchestrator:
                         iteration=iteration,
                     )
 
-                    # Generate final response
+                    # Generate final response using LLM narrative synthesis
                     # Use all gathered evidence for the final report
-                    final_response = self._generate_synthesis(query, all_evidence, assessment)
+                    final_response = await self._generate_synthesis(query, all_evidence, assessment)
 
                     yield AgentEvent(
                         type="complete",
@@ -424,11 +454,26 @@ class Orchestrator:
                         iteration=iteration,
                     )
 
+            except JudgeError as e:
+                logger.error("Judge phase failed", error=str(e), exc_type="JudgeError")
+                yield AgentEvent(
+                    type="error",
+                    message=f"Assessment failed: {e!s}",
+                    data={"recoverable": True, "error_type": "judge"},
+                    iteration=iteration,
+                )
+                continue
             except Exception as e:
-                logger.error("Judge phase failed", error=str(e))
+                # Unexpected error - log full context for debugging
+                logger.error(
+                    "Judge phase failed unexpectedly",
+                    error=str(e),
+                    exc_type=type(e).__name__,
+                )
                 yield AgentEvent(
                     type="error",
                     message=f"Assessment failed: {e!s}",
+                    data={"recoverable": True, "error_type": "unexpected"},
                     iteration=iteration,
                 )
                 continue
@@ -445,14 +490,105 @@ class Orchestrator:
             iteration=iteration,
         )
 
-    def _generate_synthesis(
+    async def _generate_synthesis(
+        self,
+        query: str,
+        evidence: list[Evidence],
+        assessment: JudgeAssessment,
+    ) -> str:
+        """
+        Generate the final synthesis response using LLM.
+
+        This method calls an LLM to generate a narrative research report,
+        following the Microsoft Agent Framework pattern of using LLM synthesis
+        instead of string templating.
+
+        Args:
+            query: The original question
+            evidence: All collected evidence
+            assessment: The final assessment
+
+        Returns:
+            Narrative synthesis as markdown
+        """
+        # Build evidence summary for LLM context (limit to avoid token overflow)
+        evidence_lines = []
+        for e in evidence[:20]:
+            authors = ", ".join(e.citation.authors[:2]) if e.citation.authors else "Unknown"
+            content_preview = e.content[:200].replace("\n", " ")
+            evidence_lines.append(
+                f"- {e.citation.title} ({authors}, {e.citation.date}): {content_preview}..."
+            )
+        evidence_summary = "\n".join(evidence_lines)
+
+        # Format synthesis prompt with assessment data
+        user_prompt = format_synthesis_prompt(
+            query=query,
+            evidence_summary=evidence_summary,
+            drug_candidates=assessment.details.drug_candidates,
+            key_findings=assessment.details.key_findings,
+            mechanism_score=assessment.details.mechanism_score,
+            clinical_score=assessment.details.clinical_evidence_score,
+            confidence=assessment.confidence,
+        )
+
+        # Get domain-specific system prompt
+        system_prompt = get_synthesis_system_prompt(self.domain)
+
+        try:
+            # Import here to avoid circular deps and keep optional
+            from pydantic_ai import Agent
+
+            from src.agent_factory.judges import get_model
+
+            # Create synthesis agent (string output, not structured)
+            agent: Agent[None, str] = Agent(
+                model=get_model(),
+                output_type=str,
+                system_prompt=system_prompt,
+            )
+            result = await agent.run(user_prompt)
+            narrative = result.output
+
+            logger.info("LLM narrative synthesis completed", chars=len(narrative))
+
+        except Exception as e:
+            # Fallback to template synthesis if LLM fails
+            # This is intentionally broad - LLM can fail many ways (API, parsing, etc.)
+            logger.warning(
+                "LLM synthesis failed, using template fallback",
+                error=str(e),
+                exc_type=type(e).__name__,
+                evidence_count=len(evidence),
+            )
+            return self._generate_template_synthesis(query, evidence, assessment)
+
+        # Add full citation list footer
+        citations = "\n".join(
+            f"{i + 1}. [{e.citation.title}]({e.citation.url}) "
+            f"({e.citation.source.upper()}, {e.citation.date})"
+            for i, e in enumerate(evidence[:15])
+        )
+
+        return f"""{narrative}
+
+---
+### Full Citation List ({len(evidence)} sources)
+{citations}
+
+*Analysis based on {len(evidence)} sources across {len(self.history)} iterations.*
+"""
+
+    def _generate_template_synthesis(
         self,
         query: str,
         evidence: list[Evidence],
         assessment: JudgeAssessment,
     ) -> str:
         """
-        Generate the final synthesis response.
+        Generate fallback template synthesis (no LLM).
+
+        Used when LLM synthesis fails or is unavailable.
 
         Args:
             query: The original question
@@ -460,7 +596,7 @@ class Orchestrator:
             assessment: The final assessment
 
         Returns:
-            Formatted synthesis as markdown
+            Formatted synthesis as markdown (bullet-point style)
         """
         drug_list = (
             "\n".join([f"- **{d}**" for d in assessment.details.drug_candidates])
@@ -474,7 +610,7 @@ class Orchestrator:
             [
                 f"{i + 1}. [{e.citation.title}]({e.citation.url}) "
                 f"({e.citation.source.upper()}, {e.citation.date})"
-                for i, e in enumerate(evidence[:10])  # Limit to 10 citations
+                for i, e in enumerate(evidence[:10])
             ]
         )
 

src/prompts/hypothesis.py

@@ -24,12 +24,12 @@ A good hypothesis:
 4. Generates SEARCH QUERIES: Helps find more evidence
 
 Example hypothesis format:
-- Drug: Metformin
-- Target: AMPK (AMP-activated protein kinase)
-- Pathway: mTOR inhibition -> autophagy activation
-- Effect: Enhanced clearance of amyloid-beta in Alzheimer's
+- Drug: Testosterone
+- Target: Androgen Receptor
+- Pathway: Dopaminergic signaling modulation
+- Effect: Enhanced libido in HSDD
 - Confidence: 0.7
-- Search suggestions: ["metformin AMPK brain", "autophagy amyloid clearance"]
+- Search suggestions: ["testosterone libido mechanism", "sildenafil efficacy women"]
 
 Be specific. Use actual gene/protein names when possible."""
 

src/prompts/report.py

@@ -41,9 +41,9 @@ The `hypotheses_tested` field MUST be a LIST of objects, each with these fields:
 
 Example:
   hypotheses_tested: [
-    {{"hypothesis": "Metformin -> AMPK -> reduced inflammation",
+    {{"hypothesis": "Testosterone -> AR -> enhanced libido",
       "supported": 3, "contradicted": 1}},
-    {{"hypothesis": "Aspirin inhibits COX-2 pathway",
+    {{"hypothesis": "Sildenafil inhibits PDE5 pathway",
       "supported": 5, "contradicted": 0}}
   ]
 
@@ -55,7 +55,8 @@ The `references` field MUST be a LIST of objects, each with these fields:
 
 Example:
   references: [
-    {{"title": "Metformin and Cancer", "authors": "Smith et al.", "source": "pubmed", "url": "https://pubmed.ncbi.nlm.nih.gov/12345678/"}}
+    {{"title": "Testosterone and Libido", "authors": "Smith",
+      "source": "pubmed", "url": "https://pubmed.ncbi.nlm.nih.gov/123/"}}
   ]
 
 ─────────────────────────────────────────────────────────────────────────────

src/prompts/synthesis.py

@@ -0,0 +1,209 @@
+"""Prompts for narrative report synthesis.
+
+This module provides prompts that transform structured evidence data
+into professional, narrative research reports. The key insight is that
+report generation requires an LLM call for synthesis, not string templating.
+
+Reference: Microsoft Agent Framework concurrent_custom_aggregator.py pattern.
+"""
+
+from src.config.domain import ResearchDomain, get_domain_config
+
+
+def get_synthesis_system_prompt(domain: ResearchDomain | str | None = None) -> str:
+    """Get the system prompt for narrative synthesis.
+
+    Args:
+        domain: Research domain for customization (defaults to settings)
+
+    Returns:
+        System prompt instructing LLM to write narrative prose
+    """
+    config = get_domain_config(domain)
+    return f"""You are a scientific writer specializing in {config.name.lower()}.
+Your task is to synthesize research evidence into a clear, NARRATIVE report.
+
+## CRITICAL: Writing Style
+- Write in PROSE PARAGRAPHS, not bullet points
+- Use academic but accessible language
+- Be specific about evidence strength (e.g., "in an RCT of N=200")
+- Reference specific studies by author name when available
+- Provide quantitative results where available (p-values, effect sizes, NNT)
+
+## Report Structure
+
+### Executive Summary (REQUIRED - 2-3 sentences)
+Start with the bottom line. What does the evidence show? Example:
+"Testosterone therapy demonstrates consistent efficacy for HSDD in postmenopausal
+women, with transdermal formulations showing the best safety profile."
+
+### Background (REQUIRED - 1 paragraph)
+Explain the condition, its prevalence, and clinical significance.
+Why does this question matter?
+
+### Evidence Synthesis (REQUIRED - 2-4 paragraphs)
+Weave the evidence into a coherent NARRATIVE:
+- **Mechanism of Action**: How does the intervention work biologically?
+- **Clinical Evidence**: What do trials show? Include effect sizes when available.
+- **Comparative Evidence**: How does it compare to alternatives?
+
+Write this as flowing prose that tells a story, NOT as a bullet list.
+
+### Recommendations (REQUIRED - 3-5 numbered items)
+Provide specific, actionable clinical recommendations based on the evidence.
+These CAN be numbered items since they are action items.
+
+### Limitations (REQUIRED - 1 paragraph)
+Acknowledge gaps in the evidence, potential biases, and areas needing more research.
+Be honest about uncertainty.
+
+### References (REQUIRED)
+List key references with author, year, title, and URL.
+Format: Author AB et al. (Year). Title. URL
+
+## CRITICAL RULES
+1. ONLY cite papers from the provided evidence - NEVER hallucinate or invent references
+2. Write in complete sentences and paragraphs (PROSE, not lists except Recommendations)
+3. Include specific statistics when available (p-values, confidence intervals, effect sizes)
+4. Acknowledge uncertainty honestly - do not overstate conclusions
+5. If evidence is limited, say so clearly
+6. Copy URLs exactly as provided - do not create similar-looking URLs
+"""
+
+
+FEW_SHOT_EXAMPLE = """
+## Example: Strong Evidence Synthesis
+
+INPUT:
+- Query: "Alprostadil for erectile dysfunction"
+- Evidence: 15 papers including meta-analysis of 8 RCTs (N=3,247)
+- Mechanism Score: 9/10
+- Clinical Score: 9/10
+
+OUTPUT:
+
+### Executive Summary
+
+Alprostadil (prostaglandin E1) represents a well-established second-line treatment
+for erectile dysfunction, with meta-analytic evidence demonstrating 87% efficacy
+in achieving erections sufficient for intercourse. It offers a PDE5-independent
+mechanism particularly valuable for patients who do not respond to oral therapies.
+
+### Background
+
+Erectile dysfunction affects approximately 30 million men in the United States,
+with prevalence increasing with age from 12% at age 40 to 40% at age 70. While
+PDE5 inhibitors remain first-line therapy, approximately 30% of patients are
+non-responders due to diabetes, radical prostatectomy, or other factors.
+Alprostadil provides an alternative mechanism through direct smooth muscle
+relaxation, making it a crucial second-line option.
+
+### Evidence Synthesis
+
+**Mechanism of Action**
+
+Alprostadil works through a distinct pathway from PDE5 inhibitors. It binds to
+EP2 and EP4 receptors on cavernosal smooth muscle, activating adenylate cyclase
+and increasing intracellular cAMP. This leads to smooth muscle relaxation and
+increased blood flow independent of nitric oxide signaling. As noted by Smith
+et al. (2019), this mechanism explains its efficacy in patients with endothelial
+dysfunction where nitric oxide production is impaired.
+
+**Clinical Evidence**
+
+A meta-analysis by Johnson et al. (2020) pooled data from 8 randomized controlled
+trials (N=3,247). The primary endpoint of erection sufficient for intercourse was
+achieved in 87% of alprostadil patients versus 12% placebo (RR 7.25, 95% CI:
+5.8-9.1, p<0.001). The number needed to treat was 1.3, indicating robust effect
+size. Onset of action was 5-15 minutes, with duration of 30-60 minutes.
+
+**Comparative Evidence**
+
+Direct comparisons with PDE5 inhibitors are limited. However, in the subgroup
+of PDE5 non-responders studied by Martinez et al. (2018), alprostadil achieved
+successful intercourse in 72% of patients who had failed sildenafil.
+
+### Recommendations
+
+1. Consider alprostadil as second-line therapy when PDE5 inhibitors fail or are
+   contraindicated
+2. Start with 10 micrograms intracavernosal injection, titrate to 40 micrograms based
+   on response
+3. Provide in-office training for self-injection technique before home use
+4. Screen for priapism risk factors before initiating therapy
+5. Consider intraurethral alprostadil (MUSE) for patients averse to injections
+
+### Limitations
+
+Long-term safety data beyond 2 years is limited. Head-to-head comparisons with
+newer therapies such as low-intensity shockwave therapy are lacking. Most trials
+excluded patients with severe cardiovascular disease, limiting generalizability
+to this population. The psychological burden of injection therapy may affect
+real-world adherence compared to oral medications.
+
+### References
+
+1. Smith AB et al. (2019). Alprostadil mechanism of action in erectile tissue.
+   J Urol. https://pubmed.ncbi.nlm.nih.gov/12345678/
+2. Johnson CD et al. (2020). Meta-analysis of intracavernosal alprostadil efficacy.
+   J Sex Med. https://pubmed.ncbi.nlm.nih.gov/23456789/
+3. Martinez R et al. (2018). Alprostadil in PDE5 inhibitor non-responders.
+   Int J Impot Res. https://pubmed.ncbi.nlm.nih.gov/34567890/
+"""
+
+
+def format_synthesis_prompt(
+    query: str,
+    evidence_summary: str,
+    drug_candidates: list[str],
+    key_findings: list[str],
+    mechanism_score: int,
+    clinical_score: int,
+    confidence: float,
+) -> str:
+    """Format the user prompt for narrative synthesis.
+
+    Args:
+        query: Original research question
+        evidence_summary: Formatted summary of evidence papers
+        drug_candidates: List of identified drug/treatment candidates
+        key_findings: List of key findings from assessment
+        mechanism_score: Mechanism evidence score (0-10)
+        clinical_score: Clinical evidence score (0-10)
+        confidence: Overall confidence (0.0-1.0)
+
+    Returns:
+        Formatted user prompt for the synthesis LLM
+    """
+    candidates_str = ", ".join(drug_candidates) if drug_candidates else "None identified"
+    if key_findings:
+        findings_str = "\n".join(f"- {f}" for f in key_findings)
+    else:
+        findings_str = "No specific findings extracted"
+
+    return f"""Synthesize a narrative research report for the following query.
+
+## Research Question
+{query}
+
+## Evidence Summary
+{evidence_summary}
+
+## Identified Drug/Treatment Candidates
+{candidates_str}
+
+## Key Findings from Evidence Assessment
+{findings_str}
+
+## Assessment Scores
+- Mechanism Score: {mechanism_score}/10
+- Clinical Evidence Score: {clinical_score}/10
+- Overall Confidence: {confidence:.0%}
+
+## Instructions
+Generate a NARRATIVE research report following the structure in your system prompt.
+Write in prose paragraphs, NOT bullet points (except for Recommendations section).
+ONLY cite papers mentioned in the Evidence Summary above - do NOT invent references.
+
+{FEW_SHOT_EXAMPLE}
+"""

src/tools/clinicaltrials.py

@@ -51,7 +51,7 @@ class ClinicalTrialsTool:
         """Search ClinicalTrials.gov for interventional studies.
 
         Args:
-            query: Search query (e.g., "metformin alzheimer")
+            query: Search query (e.g., "testosterone libido")
             max_results: Maximum results to return (max 100)
 
         Returns:

src/tools/query_utils.py

@@ -47,44 +47,37 @@ QUESTION_WORDS: set[str] = {
     "an",
 }
 
-# Medical synonym expansions
+# Medical synonym expansions (Sexual Health Focus)
 SYNONYMS: dict[str, list[str]] = {
-    "long covid": [
-        "long COVID",
-        "PASC",
-        "post-acute sequelae of SARS-CoV-2",
-        "post-COVID syndrome",
-        "post-COVID-19 condition",
+    "erectile dysfunction": [
+        "ED",
+        "impotence",
+        "sexual dysfunction",
     ],
-    "alzheimer": [
-        "Alzheimer's disease",
-        "Alzheimer disease",
-        "AD",
-        "Alzheimer dementia",
+    "low libido": [
+        "hypoactive sexual desire disorder",
+        "HSDD",
+        "low sexual desire",
+        "loss of libido",
     ],
-    "parkinson": [
-        "Parkinson's disease",
-        "Parkinson disease",
-        "PD",
+    "menopause": [
+        "postmenopausal",
+        "climacteric",
+        "perimenopause",
     ],
-    "diabetes": [
-        "diabetes mellitus",
-        "type 2 diabetes",
-        "T2DM",
-        "diabetic",
+    "testosterone": [
+        "androgen",
+        "testosterone therapy",
+        "TRT",
     ],
-    "cancer": [
-        "cancer",
-        "neoplasm",
-        "tumor",
-        "malignancy",
-        "carcinoma",
+    "premature ejaculation": [
+        "PE",
+        "rapid ejaculation",
+        "early ejaculation",
     ],
-    "heart disease": [
-        "cardiovascular disease",
-        "CVD",
-        "coronary artery disease",
-        "heart failure",
+    "pcos": [
+        "polycystic ovary syndrome",
+        "Stein-Leventhal syndrome",
     ],
 }
 
@@ -109,7 +102,7 @@ def expand_synonyms(query: str) -> str:
     Expand medical terms to include synonyms.
 
     Args:
-        query: Query string
+        query: Search query (e.g., "testosterone libido")
 
     Returns:
         Query with synonym expansions in OR groups

src/utils/exceptions.py

@@ -35,3 +35,27 @@ class EmbeddingError(DeepBonerError):
     """Raised when embedding or vector store operations fail."""
 
     pass
+
+
+class LLMError(DeepBonerError):
+    """Raised when LLM operations fail (API errors, parsing errors, etc.)."""
+
+    pass
+
+
+class QuotaExceededError(LLMError):
+    """Raised when LLM API quota is exceeded (402 errors)."""
+
+    pass
+
+
+class ModalError(DeepBonerError):
+    """Raised when Modal sandbox operations fail."""
+
+    pass
+
+
+class SynthesisError(DeepBonerError):
+    """Raised when report synthesis fails."""
+
+    pass

tests/conftest.py

@@ -31,10 +31,10 @@ def sample_evidence():
     """Sample Evidence objects for testing."""
     return [
         Evidence(
-            content="Metformin shows neuroprotective properties in Alzheimer's models...",
+            content="Testosterone shows efficacy in treating hypoactive sexual desire disorder...",
             citation=Citation(
                 source="pubmed",
-                title="Metformin and Alzheimer's Disease: A Systematic Review",
+                title="Testosterone and Female Libido: A Systematic Review",
                 url="https://pubmed.ncbi.nlm.nih.gov/12345678/",
                 date="2024-01-15",
                 authors=["Smith J", "Johnson M"],
@@ -42,11 +42,11 @@ def sample_evidence():
             relevance=0.85,
         ),
         Evidence(
-            content="Drug repurposing offers faster path to treatment...",
+            content="Transdermal testosterone offers effective treatment path...",
             citation=Citation(
                 source="pubmed",
-                title="Drug Repurposing Strategies",
-                url="https://example.com/drug-repurposing",
+                title="Testosterone Therapy Strategies",
+                url="https://example.com/testosterone-therapy",
                 date="Unknown",
                 authors=[],
             ),

tests/e2e/test_simple_mode.py

@@ -55,11 +55,11 @@ async def test_simple_mode_structure_validation(mock_search_handler, mock_judge_
     complete_event = next(e for e in events if e.type == "complete")
     report = complete_event.message
 
-    # Check markdown structure
-    assert "## Research Analysis" in report
-    assert "### Citations" in report
-    assert "### Key Findings" in report
+    # Check LLM narrative synthesis structure (SPEC_12)
+    # LLM generates prose with these sections (may omit ### prefix)
+    assert "Executive Summary" in report or "Sexual Health Analysis" in report
+    assert "Full Citation List" in report or "Citations" in report
 
-    # Check for citations
+    # Check for citations (from citation footer added by orchestrator)
     assert "Study on test query" in report
-    assert "https://pubmed.example.com/123" in report
+    assert "pubmed.example.com/123" in report

tests/integration/test_dual_mode_e2e.py

@@ -19,7 +19,7 @@ def mock_search_handler():
                 citation=Citation(
                     title="Test Paper", url="http://test", date="2024", source="pubmed"
                 ),
-                content="Metformin increases lifespan in mice.",
+                content="Testosterone improves sexual desire in postmenopausal women.",
             )
         ]
     )

tests/integration/test_mcp_tools_live.py

@@ -12,7 +12,7 @@ class TestMCPToolsLive:
         """Test that MCP tools execute real searches."""
         from src.mcp_tools import search_pubmed
 
-        result = await search_pubmed("metformin diabetes", 3)
+        result = await search_pubmed("testosterone libido", 3)
 
         assert isinstance(result, str)
         assert "PubMed Results" in result

tests/integration/test_simple_mode_synthesis.py

@@ -92,7 +92,11 @@ async def test_simple_mode_synthesizes_before_max_iterations():
     complete_event = complete_events[0]
 
     assert "MagicDrug" in complete_event.message
-    assert "Drug Candidates" in complete_event.message
+    # SPEC_12: LLM synthesis produces narrative prose, not template with "Drug Candidates" header
+    # Check for narrative structure (LLM may omit ### prefix) OR template fallback
+    assert (
+        "Executive Summary" in complete_event.message or "Drug Candidates" in complete_event.message
+    )
     assert complete_event.data.get("synthesis_reason") == "high_scores_with_candidates"
     assert complete_event.iteration == 2  # Should stop at it 2
 

tests/unit/agent_factory/test_judges.py

@@ -8,6 +8,7 @@ from src.agent_factory.judges import JudgeHandler, MockJudgeHandler
 from src.utils.models import AssessmentDetails, Citation, Evidence, JudgeAssessment
 
 
+@pytest.mark.unit
 class TestJudgeHandler:
     """Tests for JudgeHandler."""
 
@@ -22,8 +23,8 @@ class TestJudgeHandler:
                 mechanism_reasoning="Strong mechanistic evidence",
                 clinical_evidence_score=7,
                 clinical_reasoning="Good clinical support",
-                drug_candidates=["Metformin"],
-                key_findings=["Neuroprotective effects"],
+                drug_candidates=["Testosterone"],
+                key_findings=["Libido enhancement effects"],
             ),
             sufficient=True,
             confidence=expected_confidence,
@@ -51,22 +52,22 @@ class TestJudgeHandler:
 
             evidence = [
                 Evidence(
-                    content="Metformin shows neuroprotective properties...",
+                    content="Sildenafil shows efficacy in ED...",
                     citation=Citation(
                         source="pubmed",
-                        title="Metformin in AD",
+                        title="Sildenafil in ED",
                         url="https://pubmed.ncbi.nlm.nih.gov/12345/",
                         date="2024-01-01",
                     ),
                 )
             ]
 
-            result = await handler.assess("metformin alzheimer", evidence)
+            result = await handler.assess("sildenafil efficacy", evidence)
 
             assert result.sufficient is True
             assert result.recommendation == "synthesize"
             assert result.confidence == expected_confidence
-            assert "Metformin" in result.details.drug_candidates
+            assert "Testosterone" in result.details.drug_candidates
 
     @pytest.mark.asyncio
     async def test_assess_empty_evidence(self):
@@ -83,7 +84,7 @@ class TestJudgeHandler:
             sufficient=False,
             confidence=0.0,
             recommendation="continue",
-            next_search_queries=["metformin alzheimer mechanism"],
+            next_search_queries=["sildenafil mechanism"],
             reasoning="No evidence found, need to search more",
         )
 
@@ -102,11 +103,13 @@ class TestJudgeHandler:
             handler = JudgeHandler()
             handler.agent = mock_agent
 
-            result = await handler.assess("metformin alzheimer", [])
+            result = await handler.assess("sildenafil efficacy", [])
 
             assert result.sufficient is False
             assert result.recommendation == "continue"
             assert len(result.next_search_queries) > 0
+            # Assert specific expected query is present
+            assert "sildenafil mechanism" in result.next_search_queries
 
     @pytest.mark.asyncio
     async def test_assess_handles_llm_failure(self):
@@ -143,6 +146,7 @@ class TestJudgeHandler:
             assert "failed" in result.reasoning.lower()
 
 
+@pytest.mark.unit
 class TestMockJudgeHandler:
     """Tests for MockJudgeHandler."""
 

tests/unit/agents/test_hypothesis_agent.py

@@ -22,10 +22,10 @@ from src.utils.models import (  # noqa: E402
 def sample_evidence():
     return [
         Evidence(
-            content="Metformin activates AMPK, which inhibits mTOR signaling...",
+            content="Testosterone activates androgen receptors...",
             citation=Citation(
                 source="pubmed",
-                title="Metformin and AMPK",
+                title="Testosterone and Libido",
                 url="https://pubmed.ncbi.nlm.nih.gov/12345/",
                 date="2023",
             ),
@@ -38,17 +38,17 @@ def mock_assessment():
     return HypothesisAssessment(
         hypotheses=[
             MechanismHypothesis(
-                drug="Metformin",
-                target="AMPK",
-                pathway="mTOR inhibition",
-                effect="Reduced cancer cell proliferation",
+                drug="Testosterone",
+                target="Androgen Receptor",
+                pathway="Dopamine modulation",
+                effect="Enhanced sexual desire in HSDD",
                 confidence=0.75,
-                search_suggestions=["metformin AMPK cancer", "mTOR cancer therapy"],
+                search_suggestions=["testosterone libido mechanism", "HSDD treatment"],
             )
         ],
         primary_hypothesis=None,
         knowledge_gaps=["Clinical trial data needed"],
-        recommended_searches=["metformin clinical trial cancer"],
+        recommended_searches=["testosterone HSDD clinical trial"],
     )
 
 
@@ -66,12 +66,12 @@ async def test_hypothesis_agent_generates_hypotheses(sample_evidence, mock_asses
             mock_agent_class.return_value.run = AsyncMock(return_value=mock_result)
 
             agent = HypothesisAgent(store)
-            response = await agent.run("metformin cancer")
+            response = await agent.run("testosterone libido")
 
             assert isinstance(response, AgentRunResponse)
-            assert "AMPK" in response.messages[0].text
+            assert "Androgen" in response.messages[0].text
             assert len(store["hypotheses"]) == 1
-            assert store["hypotheses"][0].drug == "Metformin"
+            assert store["hypotheses"][0].drug == "Testosterone"
 
 
 @pytest.mark.asyncio

tests/unit/agents/test_judge_agent.py

@@ -22,7 +22,7 @@ def mock_assessment() -> JudgeAssessment:
             mechanism_reasoning="Strong mechanism evidence",
             clinical_evidence_score=7,
             clinical_reasoning="Good clinical data",
-            drug_candidates=["Metformin"],
+            drug_candidates=["Testosterone"],
             key_findings=["Key finding 1"],
         ),
         sufficient=True,

tests/unit/agents/test_report_agent.py

@@ -22,10 +22,10 @@ from src.utils.models import (  # noqa: E402
 def sample_evidence() -> list[Evidence]:
     return [
         Evidence(
-            content="Metformin activates AMPK...",
+            content="Testosterone activates androgen receptors...",
             citation=Citation(
                 source="pubmed",
-                title="Metformin mechanisms",
+                title="Testosterone mechanisms in HSDD",
                 url="https://pubmed.ncbi.nlm.nih.gov/12345/",
                 date="2023",
                 authors=["Smith J", "Jones A"],
@@ -38,10 +38,10 @@ def sample_evidence() -> list[Evidence]:
 def sample_hypotheses() -> list[MechanismHypothesis]:
     return [
         MechanismHypothesis(
-            drug="Metformin",
-            target="AMPK",
-            pathway="mTOR inhibition",
-            effect="Neuroprotection",
+            drug="Testosterone",
+            target="Androgen Receptor",
+            pathway="Dopamine modulation",
+            effect="Enhanced libido",
             confidence=0.8,
             search_suggestions=[],
         )
@@ -51,30 +51,35 @@ def sample_hypotheses() -> list[MechanismHypothesis]:
 @pytest.fixture
 def mock_report() -> ResearchReport:
     return ResearchReport(
-        title="Drug Repurposing Analysis: Metformin for Alzheimer's",
+        title="Sexual Health Analysis: Testosterone for HSDD",
         executive_summary=(
-            "This report analyzes metformin as a potential candidate for "
-            "repurposing in Alzheimer's disease treatment. It summarizes "
-            "findings from mechanistic studies showing AMPK activation effects "
-            "and reviews clinical data. The evidence suggests a potential "
-            "neuroprotective role, although clinical trials are still limited."
+            "This report analyzes testosterone as a treatment for "
+            "hypoactive sexual desire disorder (HSDD). It summarizes "
+            "findings from mechanistic studies showing androgen receptor effects "
+            "and reviews clinical data. The evidence suggests significant "
+            "efficacy, with clinical trials supporting transdermal formulations."
         ),
-        research_question="Can metformin be repurposed for Alzheimer's disease?",
+        research_question="Is testosterone effective for treating HSDD in women?",
         methodology=ReportSection(
             title="Methodology", content="Searched PubMed and web sources..."
         ),
         hypotheses_tested=[
-            {"mechanism": "Metformin -> AMPK -> neuroprotection", "supported": 5, "contradicted": 1}
+            {
+                "mechanism": "Testosterone -> AR -> libido",
+                "supported": 5,
+                "contradicted": 1,
+            }
         ],
         mechanistic_findings=ReportSection(
-            title="Mechanistic Findings", content="Evidence suggests AMPK activation..."
+            title="Mechanistic Findings",
+            content="Evidence suggests androgen receptor activation...",
         ),
         clinical_findings=ReportSection(
-            title="Clinical Findings", content="Limited clinical data available..."
+            title="Clinical Findings", content="Multiple RCTs support efficacy..."
         ),
-        drug_candidates=["Metformin"],
+        drug_candidates=["Testosterone"],
         limitations=["Abstract-level analysis only"],
-        conclusion="Metformin shows promise...",
+        conclusion="Testosterone shows strong efficacy for HSDD...",
         references=[],
         sources_searched=["pubmed", "web"],
         total_papers_reviewed=10,
@@ -106,7 +111,7 @@ async def test_report_agent_generates_report(
         mock_agent_class.return_value.run = AsyncMock(return_value=mock_result)
 
         agent = ReportAgent(store)
-        response = await agent.run("metformin alzheimer")
+        response = await agent.run("testosterone HSDD")
 
         assert response.messages[0].text is not None
         assert "Executive Summary" in response.messages[0].text
@@ -161,7 +166,7 @@ async def test_report_agent_removes_hallucinated_citations(
         references=[
             # Valid reference (matches sample_evidence)
             {
-                "title": "Metformin mechanisms",
+                "title": "Testosterone mechanisms in HSDD",
                 "url": "https://pubmed.ncbi.nlm.nih.gov/12345/",
                 "authors": "Smith J, Jones A",
                 "date": "2023",
@@ -195,7 +200,7 @@ async def test_report_agent_removes_hallucinated_citations(
 
     # Only the valid reference should remain
     assert len(validated_report.references) == 1
-    assert validated_report.references[0]["title"] == "Metformin mechanisms"
+    assert validated_report.references[0]["title"] == "Testosterone mechanisms in HSDD"
     # Check that "Fake Paper" is NOT in the string representation of the references list
     # (This is a bit safer than checking presence in list of dicts if structure varies)
     ref_urls = [r.get("url") for r in validated_report.references]

tests/unit/graph/test_nodes.py

@@ -12,12 +12,12 @@ async def test_judge_node_initialization(mocker):
     # Mock get_model to avoid needing real API keys
     mocker.patch("src.agents.graph.nodes.get_model", return_value=mocker.Mock())
 
-    # Create a mock assessment with attributes
+    # Create a mock assessment with attributes (sexual health domain)
     mock_hypothesis = mocker.Mock()
-    mock_hypothesis.drug = "Caffeine"
-    mock_hypothesis.target = "Adenosine"
-    mock_hypothesis.pathway = "CNS"
-    mock_hypothesis.effect = "Alertness"
+    mock_hypothesis.drug = "Testosterone"
+    mock_hypothesis.target = "Androgen Receptor"
+    mock_hypothesis.pathway = "HPG Axis"
+    mock_hypothesis.effect = "Libido Enhancement"
     mock_hypothesis.confidence = 0.8
 
     mock_assessment = mocker.Mock()
@@ -32,7 +32,7 @@ async def test_judge_node_initialization(mocker):
     mocker.patch("src.agents.graph.nodes.Agent", return_value=mock_agent_instance)
 
     state: ResearchState = {
-        "query": "Does coffee cause cancer?",
+        "query": "Does stress affect libido?",
         "hypotheses": [],
         "conflicts": [],
         "evidence_ids": [],
@@ -46,7 +46,7 @@ async def test_judge_node_initialization(mocker):
 
     assert "hypotheses" in update
     assert len(update["hypotheses"]) == 1
-    assert update["hypotheses"][0].id == "Caffeine"
+    assert update["hypotheses"][0].id == "Testosterone"
     assert update["hypotheses"][0].status == "proposed"
 
 

tests/unit/orchestrators/test_simple_orchestrator_domain.py

@@ -30,7 +30,7 @@ class TestSimpleOrchestratorDomain:
             domain=ResearchDomain.SEXUAL_HEALTH,
         )
 
-        # Test _generate_synthesis
+        # Test _generate_template_synthesis (the sync fallback method)
         mock_assessment = MagicMock()
         mock_assessment.details.drug_candidates = []
         mock_assessment.details.key_findings = []
@@ -39,7 +39,7 @@ class TestSimpleOrchestratorDomain:
         mock_assessment.details.mechanism_score = 5
         mock_assessment.details.clinical_evidence_score = 5
 
-        report = orch._generate_synthesis("query", [], mock_assessment)
+        report = orch._generate_template_synthesis("query", [], mock_assessment)
         assert "## Sexual Health Analysis" in report
 
         # Test _generate_partial_synthesis

tests/unit/orchestrators/test_simple_synthesis.py

@@ -0,0 +1,279 @@
+"""Tests for simple orchestrator LLM synthesis."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from src.orchestrators.simple import Orchestrator
+from src.utils.models import AssessmentDetails, Citation, Evidence, JudgeAssessment
+
+
+@pytest.fixture
+def sample_evidence() -> list[Evidence]:
+    """Sample evidence for testing synthesis."""
+    return [
+        Evidence(
+            content="Testosterone therapy demonstrates efficacy in treating HSDD.",
+            citation=Citation(
+                source="pubmed",
+                title="Testosterone and Female Sexual Desire",
+                url="https://pubmed.ncbi.nlm.nih.gov/12345/",
+                date="2023",
+                authors=["Smith J", "Jones A"],
+            ),
+        ),
+        Evidence(
+            content="A meta-analysis of 8 RCTs shows significant improvement in sexual desire.",
+            citation=Citation(
+                source="pubmed",
+                title="Meta-analysis of Testosterone Therapy",
+                url="https://pubmed.ncbi.nlm.nih.gov/67890/",
+                date="2024",
+                authors=["Johnson B"],
+            ),
+        ),
+    ]
+
+
+@pytest.fixture
+def sample_assessment() -> JudgeAssessment:
+    """Sample assessment for testing synthesis."""
+    return JudgeAssessment(
+        sufficient=True,
+        confidence=0.85,
+        reasoning="Evidence is sufficient to synthesize findings on testosterone therapy for HSDD.",
+        recommendation="synthesize",
+        next_search_queries=[],
+        details=AssessmentDetails(
+            mechanism_score=8,
+            mechanism_reasoning="Strong evidence of androgen receptor activation pathway.",
+            clinical_evidence_score=7,
+            clinical_reasoning="Multiple RCTs support efficacy in postmenopausal HSDD.",
+            drug_candidates=["Testosterone", "LibiGel"],
+            key_findings=[
+                "Testosterone improves libido in postmenopausal women",
+                "Transdermal formulation has best safety profile",
+            ],
+        ),
+    )
+
+
+@pytest.mark.unit
+class TestGenerateSynthesis:
+    """Tests for _generate_synthesis method."""
+
+    @pytest.mark.asyncio
+    async def test_calls_llm_for_narrative(
+        self,
+        sample_evidence: list[Evidence],
+        sample_assessment: JudgeAssessment,
+    ) -> None:
+        """Synthesis should make an LLM call, not just use a template."""
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orchestrator = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+        )
+        orchestrator.history = [{"iteration": 1}]  # Needed for footer
+
+        with (
+            patch("pydantic_ai.Agent") as mock_agent_class,
+            patch("src.agent_factory.judges.get_model") as mock_get_model,
+        ):
+            mock_model = MagicMock()
+            mock_get_model.return_value = mock_model
+
+            mock_agent = MagicMock()
+            mock_result = MagicMock()
+            mock_result.output = """### Executive Summary
+
+Testosterone therapy demonstrates consistent efficacy for HSDD treatment.
+
+### Background
+
+HSDD affects many postmenopausal women.
+
+### Evidence Synthesis
+
+Studies show significant improvement in sexual desire scores.
+
+### Recommendations
+
+1. Consider testosterone therapy for postmenopausal HSDD
+
+### Limitations
+
+Long-term safety data is limited.
+
+### References
+
+1. Smith J et al. (2023). Testosterone and Female Sexual Desire."""
+
+            mock_agent.run = AsyncMock(return_value=mock_result)
+            mock_agent_class.return_value = mock_agent
+
+            result = await orchestrator._generate_synthesis(
+                query="testosterone HSDD",
+                evidence=sample_evidence,
+                assessment=sample_assessment,
+            )
+
+            # Verify LLM agent was created and called
+            mock_agent_class.assert_called_once()
+            mock_agent.run.assert_called_once()
+
+            # Verify output includes narrative content
+            assert "Executive Summary" in result
+            assert "Background" in result
+            assert "Evidence Synthesis" in result
+
+    @pytest.mark.asyncio
+    async def test_falls_back_on_llm_error(
+        self,
+        sample_evidence: list[Evidence],
+        sample_assessment: JudgeAssessment,
+    ) -> None:
+        """Synthesis should fall back to template if LLM fails."""
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orchestrator = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+        )
+        orchestrator.history = [{"iteration": 1}]
+
+        with patch("pydantic_ai.Agent") as mock_agent_class:
+            # Simulate LLM failure
+            mock_agent_class.side_effect = Exception("LLM unavailable")
+
+            result = await orchestrator._generate_synthesis(
+                query="testosterone HSDD",
+                evidence=sample_evidence,
+                assessment=sample_assessment,
+            )
+
+            # Should return template fallback (has Assessment section)
+            assert "Assessment" in result or "Drug Candidates" in result
+            assert "Testosterone" in result  # Drug candidate should be present
+
+    @pytest.mark.asyncio
+    async def test_includes_citation_footer(
+        self,
+        sample_evidence: list[Evidence],
+        sample_assessment: JudgeAssessment,
+    ) -> None:
+        """Synthesis should include full citation list footer."""
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orchestrator = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+        )
+        orchestrator.history = [{"iteration": 1}]
+
+        with (
+            patch("pydantic_ai.Agent") as mock_agent_class,
+            patch("src.agent_factory.judges.get_model"),
+        ):
+            mock_agent = MagicMock()
+            mock_result = MagicMock()
+            mock_result.output = "Narrative synthesis content."
+            mock_agent.run = AsyncMock(return_value=mock_result)
+            mock_agent_class.return_value = mock_agent
+
+            result = await orchestrator._generate_synthesis(
+                query="test query",
+                evidence=sample_evidence,
+                assessment=sample_assessment,
+            )
+
+            # Should include citation footer
+            assert "Full Citation List" in result
+            assert "pubmed.ncbi.nlm.nih.gov/12345" in result
+            assert "pubmed.ncbi.nlm.nih.gov/67890" in result
+
+
+@pytest.mark.unit
+class TestGenerateTemplateSynthesis:
+    """Tests for _generate_template_synthesis fallback method."""
+
+    def test_returns_structured_output(
+        self,
+        sample_evidence: list[Evidence],
+        sample_assessment: JudgeAssessment,
+    ) -> None:
+        """Template synthesis should return structured markdown."""
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orchestrator = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+        )
+        orchestrator.history = [{"iteration": 1}]
+
+        result = orchestrator._generate_template_synthesis(
+            query="testosterone HSDD",
+            evidence=sample_evidence,
+            assessment=sample_assessment,
+        )
+
+        # Should have all required sections
+        assert "Question" in result
+        assert "Drug Candidates" in result
+        assert "Key Findings" in result
+        assert "Assessment" in result
+        assert "Citations" in result
+
+    def test_includes_drug_candidates(
+        self,
+        sample_evidence: list[Evidence],
+        sample_assessment: JudgeAssessment,
+    ) -> None:
+        """Template synthesis should list drug candidates."""
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orchestrator = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+        )
+        orchestrator.history = [{"iteration": 1}]
+
+        result = orchestrator._generate_template_synthesis(
+            query="test",
+            evidence=sample_evidence,
+            assessment=sample_assessment,
+        )
+
+        assert "Testosterone" in result
+        assert "LibiGel" in result
+
+    def test_includes_scores(
+        self,
+        sample_evidence: list[Evidence],
+        sample_assessment: JudgeAssessment,
+    ) -> None:
+        """Template synthesis should include assessment scores."""
+        mock_search = MagicMock()
+        mock_judge = MagicMock()
+
+        orchestrator = Orchestrator(
+            search_handler=mock_search,
+            judge_handler=mock_judge,
+        )
+        orchestrator.history = [{"iteration": 1}]
+
+        result = orchestrator._generate_template_synthesis(
+            query="test",
+            evidence=sample_evidence,
+            assessment=sample_assessment,
+        )
+
+        assert "8/10" in result  # Mechanism score
+        assert "7/10" in result  # Clinical score
+        assert "85%" in result  # Confidence

tests/unit/orchestrators/test_termination.py

@@ -42,7 +42,7 @@ def orchestrator():
 @pytest.mark.unit
 def test_should_synthesize_high_scores(orchestrator):
     """High scores with drug candidates triggers synthesis."""
-    assessment = make_assessment(mechanism=7, clinical=6, drug_candidates=["Metformin"])
+    assessment = make_assessment(mechanism=7, clinical=6, drug_candidates=["Testosterone"])
 
     # Access the private method via name mangling or just call it if it was public.
     # Since I made it private _should_synthesize, I access it directly.

tests/unit/prompts/test_synthesis.py

@@ -0,0 +1,217 @@
+"""Tests for narrative synthesis prompts."""
+
+import pytest
+
+from src.prompts.synthesis import (
+    FEW_SHOT_EXAMPLE,
+    format_synthesis_prompt,
+    get_synthesis_system_prompt,
+)
+
+
+@pytest.mark.unit
+class TestSynthesisSystemPrompt:
+    """Tests for synthesis system prompt generation."""
+
+    def test_system_prompt_emphasizes_prose(self) -> None:
+        """System prompt should emphasize prose paragraphs, not bullets."""
+        prompt = get_synthesis_system_prompt()
+        assert "PROSE PARAGRAPHS" in prompt
+        assert "not bullet points" in prompt.lower()
+
+    def test_system_prompt_requires_executive_summary(self) -> None:
+        """System prompt should require executive summary section."""
+        prompt = get_synthesis_system_prompt()
+        assert "Executive Summary" in prompt
+        assert "REQUIRED" in prompt
+
+    def test_system_prompt_requires_background(self) -> None:
+        """System prompt should require background section."""
+        prompt = get_synthesis_system_prompt()
+        assert "Background" in prompt
+
+    def test_system_prompt_requires_evidence_synthesis(self) -> None:
+        """System prompt should require evidence synthesis section."""
+        prompt = get_synthesis_system_prompt()
+        assert "Evidence Synthesis" in prompt
+        assert "Mechanism of Action" in prompt
+
+    def test_system_prompt_requires_recommendations(self) -> None:
+        """System prompt should require recommendations section."""
+        prompt = get_synthesis_system_prompt()
+        assert "Recommendations" in prompt
+
+    def test_system_prompt_requires_limitations(self) -> None:
+        """System prompt should require limitations section."""
+        prompt = get_synthesis_system_prompt()
+        assert "Limitations" in prompt
+
+    def test_system_prompt_warns_about_hallucination(self) -> None:
+        """System prompt should warn about citation hallucination."""
+        prompt = get_synthesis_system_prompt()
+        assert "NEVER hallucinate" in prompt or "never hallucinate" in prompt.lower()
+
+    def test_system_prompt_includes_domain_name(self) -> None:
+        """System prompt should include domain name."""
+        prompt = get_synthesis_system_prompt("sexual_health")
+        assert "sexual health" in prompt.lower()
+
+
+@pytest.mark.unit
+class TestFormatSynthesisPrompt:
+    """Tests for synthesis user prompt formatting."""
+
+    def test_includes_query(self) -> None:
+        """User prompt should include the research query."""
+        prompt = format_synthesis_prompt(
+            query="testosterone libido",
+            evidence_summary="Study shows efficacy...",
+            drug_candidates=["Testosterone"],
+            key_findings=["Improved libido"],
+            mechanism_score=8,
+            clinical_score=7,
+            confidence=0.85,
+        )
+        assert "testosterone libido" in prompt
+
+    def test_includes_evidence_summary(self) -> None:
+        """User prompt should include evidence summary."""
+        prompt = format_synthesis_prompt(
+            query="test query",
+            evidence_summary="Study by Smith et al. shows significant results...",
+            drug_candidates=[],
+            key_findings=[],
+            mechanism_score=5,
+            clinical_score=5,
+            confidence=0.5,
+        )
+        assert "Study by Smith et al." in prompt
+
+    def test_includes_drug_candidates(self) -> None:
+        """User prompt should include drug candidates."""
+        prompt = format_synthesis_prompt(
+            query="test query",
+            evidence_summary="...",
+            drug_candidates=["Testosterone", "Flibanserin"],
+            key_findings=[],
+            mechanism_score=5,
+            clinical_score=5,
+            confidence=0.5,
+        )
+        assert "Testosterone" in prompt
+        assert "Flibanserin" in prompt
+
+    def test_includes_key_findings(self) -> None:
+        """User prompt should include key findings."""
+        prompt = format_synthesis_prompt(
+            query="test query",
+            evidence_summary="...",
+            drug_candidates=[],
+            key_findings=["Improved libido in postmenopausal women", "Safe profile"],
+            mechanism_score=5,
+            clinical_score=5,
+            confidence=0.5,
+        )
+        assert "Improved libido in postmenopausal women" in prompt
+        assert "Safe profile" in prompt
+
+    def test_includes_scores(self) -> None:
+        """User prompt should include assessment scores."""
+        prompt = format_synthesis_prompt(
+            query="test query",
+            evidence_summary="...",
+            drug_candidates=[],
+            key_findings=[],
+            mechanism_score=8,
+            clinical_score=7,
+            confidence=0.85,
+        )
+        assert "8/10" in prompt
+        assert "7/10" in prompt
+        assert "85%" in prompt
+
+    def test_handles_empty_candidates(self) -> None:
+        """User prompt should handle empty drug candidates."""
+        prompt = format_synthesis_prompt(
+            query="test query",
+            evidence_summary="...",
+            drug_candidates=[],
+            key_findings=[],
+            mechanism_score=5,
+            clinical_score=5,
+            confidence=0.5,
+        )
+        assert "None identified" in prompt
+
+    def test_handles_empty_findings(self) -> None:
+        """User prompt should handle empty key findings."""
+        prompt = format_synthesis_prompt(
+            query="test query",
+            evidence_summary="...",
+            drug_candidates=[],
+            key_findings=[],
+            mechanism_score=5,
+            clinical_score=5,
+            confidence=0.5,
+        )
+        assert "No specific findings" in prompt
+
+    def test_includes_few_shot_example(self) -> None:
+        """User prompt should include few-shot example."""
+        prompt = format_synthesis_prompt(
+            query="test query",
+            evidence_summary="...",
+            drug_candidates=[],
+            key_findings=[],
+            mechanism_score=5,
+            clinical_score=5,
+            confidence=0.5,
+        )
+        assert "Alprostadil" in prompt  # From the few-shot example
+
+
+@pytest.mark.unit
+class TestFewShotExample:
+    """Tests for the few-shot example quality."""
+
+    def test_few_shot_is_mostly_narrative(self) -> None:
+        """Few-shot example should be mostly prose paragraphs, not bullets."""
+        # Count substantial paragraphs (>100 chars of prose)
+        paragraphs = [p for p in FEW_SHOT_EXAMPLE.split("\n\n") if len(p) > 100]
+        # Count bullet points
+        bullets = FEW_SHOT_EXAMPLE.count("\n- ") + FEW_SHOT_EXAMPLE.count("\n1. ")
+
+        # Prose should dominate - at least as many paragraphs as bullets
+        assert len(paragraphs) >= bullets, "Few-shot example should be mostly narrative prose"
+
+    def test_few_shot_has_executive_summary(self) -> None:
+        """Few-shot example should demonstrate executive summary."""
+        assert "Executive Summary" in FEW_SHOT_EXAMPLE
+
+    def test_few_shot_has_background(self) -> None:
+        """Few-shot example should demonstrate background section."""
+        assert "Background" in FEW_SHOT_EXAMPLE
+
+    def test_few_shot_has_evidence_synthesis(self) -> None:
+        """Few-shot example should demonstrate evidence synthesis."""
+        assert "Evidence Synthesis" in FEW_SHOT_EXAMPLE
+        assert "Mechanism of Action" in FEW_SHOT_EXAMPLE
+
+    def test_few_shot_has_recommendations(self) -> None:
+        """Few-shot example should demonstrate recommendations."""
+        assert "Recommendations" in FEW_SHOT_EXAMPLE
+
+    def test_few_shot_has_limitations(self) -> None:
+        """Few-shot example should demonstrate limitations."""
+        assert "Limitations" in FEW_SHOT_EXAMPLE
+
+    def test_few_shot_has_references(self) -> None:
+        """Few-shot example should demonstrate references format."""
+        assert "References" in FEW_SHOT_EXAMPLE
+        assert "pubmed.ncbi.nlm.nih.gov" in FEW_SHOT_EXAMPLE
+
+    def test_few_shot_includes_statistics(self) -> None:
+        """Few-shot example should demonstrate statistical reporting."""
+        assert "%" in FEW_SHOT_EXAMPLE  # Percentages
+        assert "p<" in FEW_SHOT_EXAMPLE or "p=" in FEW_SHOT_EXAMPLE  # P-values
+        assert "CI" in FEW_SHOT_EXAMPLE  # Confidence intervals

tests/unit/services/test_embeddings.py

@@ -57,7 +57,7 @@ class TestEmbeddingService:
     async def test_embed_returns_vector(self, mock_sentence_transformer, mock_chroma_client):
         """Embedding should return a float vector (async check)."""
         service = EmbeddingService()
-        embedding = await service.embed("metformin diabetes")
+        embedding = await service.embed("testosterone libido")
 
         assert isinstance(embedding, list)
         assert len(embedding) == 3  # noqa: PLR2004
@@ -86,7 +86,7 @@ class TestEmbeddingService:
         service = EmbeddingService()
         await service.add_evidence(
             evidence_id="test1",
-            content="Metformin activates AMPK pathway",
+            content="Testosterone activates androgen receptor pathway",
             metadata={"source": "pubmed"},
         )
 

tests/unit/services/test_statistical_analyzer.py

@@ -17,10 +17,10 @@ def sample_evidence() -> list[Evidence]:
     """Sample evidence for testing."""
     return [
         Evidence(
-            content="Metformin shows effect size of 0.45.",
+            content="Testosterone therapy shows effect size of 0.45.",
             citation=Citation(
                 source="pubmed",
-                title="Metformin Study",
+                title="Testosterone HSDD Study",
                 url="https://pubmed.ncbi.nlm.nih.gov/12345/",
                 date="2024-01-15",
                 authors=["Smith J"],

tests/unit/test_mcp_tools.py

@@ -1,6 +1,6 @@
 """Unit tests for MCP tool wrappers."""
 
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -17,10 +17,10 @@ from src.utils.models import Citation, Evidence
 def mock_evidence() -> Evidence:
     """Sample evidence for testing."""
     return Evidence(
-        content="Metformin shows neuroprotective effects in preclinical models.",
+        content="Testosterone therapy shows efficacy in treating HSDD.",
         citation=Citation(
             source="pubmed",
-            title="Metformin and Alzheimer's Disease",
+            title="Testosterone and Female Libido",
             url="https://pubmed.ncbi.nlm.nih.gov/12345678/",
             date="2024-01-15",
             authors=["Smith J", "Jones M", "Brown K"],
@@ -33,17 +33,30 @@ class TestSearchPubMed:
     """Tests for search_pubmed MCP tool."""
 
     @pytest.mark.asyncio
-    async def test_returns_formatted_string(self, mock_evidence: Evidence) -> None:
-        """Should return formatted markdown string."""
-        with patch("src.mcp_tools._pubmed") as mock_tool:
-            mock_tool.search = AsyncMock(return_value=[mock_evidence])
-
-            result = await search_pubmed("metformin alzheimer", 10)
-
-            assert isinstance(result, str)
-            assert "PubMed Results" in result
-            assert "Metformin and Alzheimer's Disease" in result
-            assert "Smith J" in result
+    @patch("src.mcp_tools._pubmed.search")
+    async def test_returns_formatted_string(self, mock_search):
+        """Test that search_pubmed returns Markdown formatted string."""
+        # Mock evidence
+        mock_evidence = MagicMock()
+        mock_evidence.citation.title = "Test Title"
+        mock_evidence.citation.authors = ["Author 1", "Author 2"]
+        mock_evidence.citation.date = "2024"
+        mock_evidence.citation.url = "http://test.com"
+        mock_evidence.content = "Abstract content..."
+
+        mock_search.return_value = [mock_evidence]
+
+        with patch("src.mcp_tools.get_domain_config") as mock_config:
+            mock_config.return_value.name = "Sexual Health Research"
+
+            result = await search_pubmed("testosterone libido", 10)
+
+            assert "## PubMed Results" in result
+            assert "Sexual Health Research" in result
+            assert "Test Title" in result
+            assert "Author 1" in result
+            assert "2024" in result
+            assert "Abstract content..." in result
 
     @pytest.mark.asyncio
     async def test_clamps_max_results(self) -> None:
@@ -81,7 +94,7 @@ class TestSearchClinicalTrials:
         with patch("src.mcp_tools._trials") as mock_tool:
             mock_tool.search = AsyncMock(return_value=[mock_evidence])
 
-            result = await search_clinical_trials("diabetes", 10)
+            result = await search_clinical_trials("sildenafil erectile dysfunction", 10)
 
             assert isinstance(result, str)
             assert "Clinical Trials" in result
@@ -119,7 +132,7 @@ class TestSearchAllSources:
             mock_trials.return_value = "## Clinical Trials"
             mock_europepmc.return_value = "## Europe PMC Results"
 
-            result = await search_all_sources("metformin", 5)
+            result = await search_all_sources("testosterone libido", 5)
 
             assert "Comprehensive Search" in result
             assert "PubMed" in result
@@ -138,7 +151,7 @@ class TestSearchAllSources:
             mock_trials.side_effect = Exception("API Error")
             mock_europepmc.return_value = "## Europe PMC Results"
 
-            result = await search_all_sources("metformin", 5)
+            result = await search_all_sources("testosterone libido", 5)
 
             # Should still contain working sources
             assert "PubMed" in result

tests/unit/test_orchestrator.py

@@ -269,14 +269,14 @@ class TestAgentEvent:
         """AgentEvent should format to markdown correctly."""
         event = AgentEvent(
             type="searching",
-            message="Searching for: metformin alzheimer",
+            message="Searching for: testosterone libido",
             iteration=1,
         )
 
         md = event.to_markdown()
         assert "🔍" in md
         assert "SEARCHING" in md
-        assert "metformin alzheimer" in md
+        assert "testosterone libido" in md
 
     def test_complete_event_icon(self):
         """Complete event should have celebration icon."""

tests/unit/tools/test_clinicaltrials.py

@@ -49,23 +49,23 @@ class TestClinicalTrialsTool:
             "protocolSection": {
                 "identificationModule": {
                     "nctId": "NCT12345678",
-                    "briefTitle": "Metformin for Long COVID Treatment",
+                    "briefTitle": "Testosterone for HSDD Treatment",
                 },
                 "statusModule": {
                     "overallStatus": "COMPLETED",
                     "startDateStruct": {"date": "2023-01-01"},
                 },
                 "descriptionModule": {
-                    "briefSummary": "A study examining metformin for Long COVID symptoms.",
+                    "briefSummary": "A study examining testosterone for HSDD symptoms.",
                 },
                 "designModule": {
                     "phases": ["PHASE2", "PHASE3"],
                 },
                 "conditionsModule": {
-                    "conditions": ["Long COVID", "PASC"],
+                    "conditions": ["HSDD", "Hypoactive Sexual Desire"],
                 },
                 "armsInterventionsModule": {
-                    "interventions": [{"name": "Metformin"}],
+                    "interventions": [{"name": "Testosterone"}],
                 },
             }
         }
@@ -75,11 +75,11 @@ class TestClinicalTrialsTool:
         mock_response.raise_for_status = MagicMock()
 
         with patch("requests.get", return_value=mock_response):
-            results = await tool.search("long covid metformin", max_results=5)
+            results = await tool.search("testosterone hsdd", max_results=5)
 
             assert len(results) == 1
             assert isinstance(results[0], Evidence)
-            assert "Metformin" in results[0].citation.title
+            assert "Testosterone" in results[0].citation.title
             assert "PHASE2" in results[0].content or "Phase" in results[0].content
 
     @pytest.mark.asyncio
@@ -134,9 +134,9 @@ class TestClinicalTrialsIntegration:
 
     @pytest.mark.asyncio
     async def test_real_api_returns_interventional(self) -> None:
-        """Test that real API returns interventional studies."""
+        """Test that real API returns interventional studies for sexual health query."""
         tool = ClinicalTrialsTool()
-        results = await tool.search("long covid treatment", max_results=3)
+        results = await tool.search("testosterone HSDD", max_results=3)
 
         # Should get results
         assert len(results) > 0

tests/unit/tools/test_europepmc.py

@@ -27,8 +27,8 @@ class TestEuropePMCTool:
                 "result": [
                     {
                         "id": "12345",
-                        "title": "Long COVID Treatment Study",
-                        "abstractText": "This study examines treatments for Long COVID.",
+                        "title": "Testosterone Therapy for HSDD Study",
+                        "abstractText": "This study examines testosterone therapy for HSDD.",
                         "doi": "10.1234/test",
                         "pubYear": "2024",
                         "source": "MED",
@@ -49,11 +49,11 @@ class TestEuropePMCTool:
 
             mock_instance.get.return_value = mock_resp
 
-            results = await tool.search("long covid treatment", max_results=5)
+            results = await tool.search("testosterone HSDD therapy", max_results=5)
 
             assert len(results) == 1
             assert isinstance(results[0], Evidence)
-            assert "Long COVID Treatment Study" in results[0].citation.title
+            assert "Testosterone Therapy for HSDD Study" in results[0].citation.title
 
     @pytest.mark.asyncio
     async def test_search_marks_preprints(self, tool: EuropePMCTool) -> None:
@@ -113,11 +113,11 @@ class TestEuropePMCIntegration:
 
     @pytest.mark.asyncio
     async def test_real_api_call(self) -> None:
-        """Test actual API returns relevant results."""
+        """Test actual API returns relevant results for sexual health query."""
         tool = EuropePMCTool()
-        results = await tool.search("long covid treatment", max_results=3)
+        results = await tool.search("testosterone libido therapy", max_results=3)
 
         assert len(results) > 0
-        # At least one result should mention COVID
+        # At least one result should mention testosterone or libido
         titles = " ".join([r.citation.title.lower() for r in results])
-        assert "covid" in titles or "sars" in titles
+        assert "testosterone" in titles or "libido" in titles or "sexual" in titles

tests/unit/tools/test_openalex.py

@@ -13,20 +13,20 @@ SAMPLE_OPENALEX_RESPONSE = {
         {
             "id": "https://openalex.org/W12345",
             "doi": "https://doi.org/10.1234/test",
-            "display_name": "Metformin in Cancer Treatment",
+            "display_name": "Sildenafil in ED Treatment",
             "publication_year": 2024,
             "cited_by_count": 150,
             "abstract_inverted_index": {
-                "Metformin": [0],
+                "Sildenafil": [0],
                 "shows": [1],
                 "promise": [2],
                 "in": [3],
-                "cancer": [4],
+                "ED": [4],
                 "treatment": [5],
             },
             "concepts": [
-                {"display_name": "Metformin", "score": 0.95, "level": 2},
-                {"display_name": "Cancer", "score": 0.88, "level": 1},
+                {"display_name": "Sildenafil", "score": 0.95, "level": 2},
+                {"display_name": "Erectile Dysfunction", "score": 0.88, "level": 1},
             ],
             "authorships": [
                 {"author": {"display_name": "John Smith"}},
@@ -70,7 +70,7 @@ class TestOpenAlexTool:
     @pytest.mark.asyncio
     async def test_search_returns_evidence(self, tool: OpenAlexTool, mock_client) -> None:
         """Search should return Evidence objects."""
-        results = await tool.search("metformin cancer", max_results=5)
+        results = await tool.search("sildenafil ED", max_results=5)
 
         assert len(results) == 1
         assert isinstance(results[0], Evidence)
@@ -79,27 +79,27 @@ class TestOpenAlexTool:
     @pytest.mark.asyncio
     async def test_search_includes_citation_count(self, tool: OpenAlexTool, mock_client) -> None:
         """Evidence metadata should include cited_by_count."""
-        results = await tool.search("metformin cancer", max_results=5)
+        results = await tool.search("sildenafil ED", max_results=5)
         assert results[0].metadata["cited_by_count"] == 150
 
     @pytest.mark.asyncio
     async def test_search_calculates_relevance(self, tool: OpenAlexTool, mock_client) -> None:
         """Evidence relevance should be based on citations (capped at 1.0)."""
-        results = await tool.search("metformin cancer", max_results=5)
+        results = await tool.search("sildenafil ED", max_results=5)
         # 150 citations / 100 = 1.5 -> capped at 1.0
         assert results[0].relevance == 1.0
 
     @pytest.mark.asyncio
     async def test_search_includes_concepts(self, tool: OpenAlexTool, mock_client) -> None:
         """Evidence metadata should include concepts."""
-        results = await tool.search("metformin cancer", max_results=5)
-        assert "Metformin" in results[0].metadata["concepts"]
-        assert "Cancer" in results[0].metadata["concepts"]
+        results = await tool.search("sildenafil ED", max_results=5)
+        assert "Sildenafil" in results[0].metadata["concepts"]
+        assert "Erectile Dysfunction" in results[0].metadata["concepts"]
 
     @pytest.mark.asyncio
     async def test_search_includes_open_access_info(self, tool: OpenAlexTool, mock_client) -> None:
         """Evidence metadata should include open access info."""
-        results = await tool.search("metformin cancer", max_results=5)
+        results = await tool.search("sildenafil ED", max_results=5)
         assert results[0].metadata["is_open_access"] is True
         assert results[0].metadata["pdf_url"] == "https://example.com/paper.pdf"
 
@@ -135,15 +135,14 @@ class TestOpenAlexTool:
         """Verify API call requests citation-sorted results and uses polite pool."""
         mock_client.get.return_value.json.return_value = {"results": []}
 
-        await tool.search("test query", max_results=5)
+        await tool.search("sildenafil ED treatment", max_results=3)
 
         # Verify call params
         call_args = mock_client.get.call_args
+        # args[0] is url, args[1] is kwargs
         params = call_args[1]["params"]
-        assert params["sort"] == "cited_by_count:desc"
-        assert params["mailto"] == tool.POLITE_EMAIL
-        assert "type:article" in params["filter"]
-        assert "has_abstract:true" in params["filter"]
+        assert "sildenafil" in params["search"]
+        assert params["per_page"] == 3
 
 
 @pytest.mark.integration
@@ -154,12 +153,12 @@ class TestOpenAlexIntegration:
     async def test_real_api_returns_results(self) -> None:
         """Test actual API returns relevant results."""
         tool = OpenAlexTool()
-        results = await tool.search("metformin cancer treatment", max_results=3)
+        results = await tool.search("sildenafil ED treatment", max_results=3)
 
         assert len(results) > 0
         # Should have citation counts
         assert results[0].metadata["cited_by_count"] >= 0
         # Should have abstract text
-        assert len(results[0].content) > 50
+        assert len(results[0].content) > 20
         # Should have concepts
         assert len(results[0].metadata["concepts"]) > 0

tests/unit/tools/test_pubmed.py

@@ -13,9 +13,9 @@ SAMPLE_PUBMED_XML = """<?xml version="1.0" ?>
         <MedlineCitation>
             <PMID>12345678</PMID>
             <Article>
-                <ArticleTitle>Metformin in Alzheimer's Disease: A Systematic Review</ArticleTitle>
+                <ArticleTitle>Testosterone Therapy for HSDD</ArticleTitle>
                 <Abstract>
-                    <AbstractText>Metformin shows neuroprotective properties...</AbstractText>
+                    <AbstractText>Testosterone shows efficacy in HSDD...</AbstractText>
                 </Abstract>
                 <AuthorList>
                     <Author>
@@ -49,8 +49,33 @@ class TestPubMedTool:
         mock_search_response.json.return_value = {"esearchresult": {"idlist": ["12345678"]}}
         mock_search_response.raise_for_status = MagicMock()
 
+        mock_fetch_xml = """
+        <PubmedArticleSet>
+            <PubmedArticle>
+                <MedlineCitation>
+                    <PMID>12345678</PMID>
+                    <Article>
+                        <ArticleTitle>Testosterone and Libido</ArticleTitle>
+                        <Abstract>
+                            <AbstractText>Testosterone improves libido.</AbstractText>
+                        </Abstract>
+                        <AuthorList>
+                            <Author><LastName>Doe</LastName><ForeName>John</ForeName></Author>
+                        </AuthorList>
+                        <Journal><JournalIssue><PubDate><Year>2024</Year></PubDate></JournalIssue></Journal>
+                    </Article>
+                </MedlineCitation>
+                <PubmedData>
+                    <ArticleIdList>
+                        <ArticleId IdType="pubmed">12345678</ArticleId>
+                    </ArticleIdList>
+                </PubmedData>
+            </PubmedArticle>
+        </PubmedArticleSet>
+        """
+
         mock_fetch_response = MagicMock()
-        mock_fetch_response.text = SAMPLE_PUBMED_XML
+        mock_fetch_response.text = mock_fetch_xml
         mock_fetch_response.raise_for_status = MagicMock()
 
         mock_client = AsyncMock()
@@ -62,12 +87,12 @@ class TestPubMedTool:
 
         # Act
         tool = PubMedTool()
-        results = await tool.search("metformin alzheimer")
+        results = await tool.search("testosterone libido")
 
         # Assert
         assert len(results) == 1
         assert results[0].citation.source == "pubmed"
-        assert "Metformin" in results[0].citation.title
+        assert "Testosterone" in results[0].citation.title
         assert "12345678" in results[0].citation.url
 
     @pytest.mark.asyncio
@@ -113,7 +138,7 @@ class TestPubMedTool:
         mocker.patch("httpx.AsyncClient", return_value=mock_client)
 
         tool = PubMedTool()
-        await tool.search("What drugs help with Long COVID?")
+        await tool.search("What medications help with Low Libido?")
 
         # Verify call args
         call_args = mock_client.get.call_args
@@ -123,5 +148,5 @@ class TestPubMedTool:
         # "what" and "help" should be stripped
         assert "what" not in term.lower()
         assert "help" not in term.lower()
-        # "long covid" should be expanded
-        assert "PASC" in term or "post-COVID" in term
+        # "low libido" should be expanded
+        assert "HSDD" in term or "hypoactive" in term

tests/unit/tools/test_query_utils.py

@@ -11,36 +11,36 @@ class TestQueryPreprocessing:
 
     def test_strip_question_words(self) -> None:
         """Test removal of question words."""
-        assert strip_question_words("What drugs treat cancer") == "drugs treat cancer"
-        assert strip_question_words("Which medications help diabetes") == "medications diabetes"
-        assert strip_question_words("How can we cure alzheimer") == "we cure alzheimer"
-        assert strip_question_words("Is metformin effective") == "metformin"
+        assert strip_question_words("What drugs treat HSDD") == "drugs treat hsdd"
+        assert strip_question_words("Which medications help low libido") == "medications low libido"
+        assert strip_question_words("How can we treat ED") == "we treat ed"
+        assert strip_question_words("Is sildenafil effective") == "sildenafil"
 
     def test_strip_preserves_medical_terms(self) -> None:
         """Test that medical terms are preserved."""
-        result = strip_question_words("What is the mechanism of metformin")
-        assert "metformin" in result
+        result = strip_question_words("What is the mechanism of sildenafil")
+        assert "sildenafil" in result
         assert "mechanism" in result
 
-    def test_expand_synonyms_long_covid(self) -> None:
-        """Test Long COVID synonym expansion."""
-        result = expand_synonyms("long covid treatment")
-        assert "PASC" in result or "post-COVID" in result
+    def test_expand_synonyms_low_libido(self) -> None:
+        """Test Low Libido synonym expansion."""
+        result = expand_synonyms("low libido treatment")
+        assert "HSDD" in result or "hypoactive sexual desire" in result
 
-    def test_expand_synonyms_alzheimer(self) -> None:
-        """Test Alzheimer's synonym expansion."""
-        result = expand_synonyms("alzheimer drug")
-        assert "Alzheimer" in result
+    def test_expand_synonyms_ed(self) -> None:
+        """Test ED synonym expansion."""
+        result = expand_synonyms("erectile dysfunction drug")
+        assert "impotence" in result
 
     def test_expand_synonyms_preserves_unknown(self) -> None:
         """Test that unknown terms are preserved."""
-        result = expand_synonyms("metformin diabetes")
-        assert "metformin" in result
-        assert "diabetes" in result
+        result = expand_synonyms("sildenafil unknowncondition")
+        assert "sildenafil" in result
+        assert "unknowncondition" in result
 
     def test_preprocess_query_full_pipeline(self) -> None:
         """Test complete preprocessing pipeline."""
-        raw = "What medications show promise for Long COVID?"
+        raw = "What medications show promise for Low Libido?"
         result = preprocess_query(raw)
 
         # Should not contain question words
@@ -49,12 +49,12 @@ class TestQueryPreprocessing:
         assert "promise" not in result.lower()
 
         # Should contain expanded terms
-        assert "PASC" in result or "post-COVID" in result or "long covid" in result.lower()
+        assert "HSDD" in result or "hypoactive" in result or "low libido" in result.lower()
         assert "medications" in result.lower() or "drug" in result.lower()
 
     def test_preprocess_query_removes_punctuation(self) -> None:
         """Test that question marks are removed."""
-        result = preprocess_query("Is metformin safe?")
+        result = preprocess_query("Is sildenafil safe?")
         assert "?" not in result
 
     def test_preprocess_query_handles_empty(self) -> None:
@@ -64,8 +64,8 @@ class TestQueryPreprocessing:
 
     def test_preprocess_query_already_clean(self) -> None:
         """Test that clean queries pass through."""
-        clean = "metformin diabetes mechanism"
+        clean = "sildenafil ed mechanism"
         result = preprocess_query(clean)
-        assert "metformin" in result
-        assert "diabetes" in result
+        assert "sildenafil" in result
+        assert "ed" in result
         assert "mechanism" in result