feat(docs): update implementation roadmap and add specs for Phases 9-11

- Updated the implementation roadmap to reflect the completion of Phases 1-8.
- Added detailed specifications for Phase 9: Remove DuckDuckGo, Phase 10: ClinicalTrials.gov Integration, and Phase 11: bioRxiv Preprint Integration.
- Enhanced the status section to indicate the completion of Phases 1-8 and readiness for Phases 9-11.

docs/implementation/09_phase_source_cleanup.md

@@ -0,0 +1,257 @@
+# Phase 9 Implementation Spec: Remove DuckDuckGo
+
+**Goal**: Remove unreliable web search, focus on credible scientific sources.
+**Philosophy**: "Scientific credibility over source quantity."
+**Prerequisite**: Phase 8 complete (all agents working)
+**Estimated Time**: 30-45 minutes
+
+---
+
+## 1. Why Remove DuckDuckGo?
+
+### Current Problems
+
+| Issue | Impact |
+|-------|--------|
+| Rate-limited aggressively | Returns 0 results frequently |
+| Not peer-reviewed | Random blogs, news, misinformation |
+| Not citable | Cannot use in scientific reports |
+| Adds noise | Dilutes quality evidence |
+
+### After Removal
+
+| Benefit | Impact |
+|---------|--------|
+| Cleaner codebase | -150 lines of dead code |
+| No rate limit failures | 100% source reliability |
+| Scientific credibility | All sources peer-reviewed/preprint |
+| Simpler debugging | Fewer failure modes |
+
+---
+
+## 2. Files to Modify/Delete
+
+### 2.1 DELETE: `src/tools/websearch.py`
+
+```bash
+# File to delete entirely
+src/tools/websearch.py  # ~80 lines
+```
+
+### 2.2 MODIFY: SearchHandler Usage
+
+Update all files that instantiate `SearchHandler` with `WebTool()`:
+
+| File | Change |
+|------|--------|
+| `examples/search_demo/run_search.py` | Remove `WebTool()` from tools list |
+| `examples/hypothesis_demo/run_hypothesis.py` | Remove `WebTool()` from tools list |
+| `examples/full_stack_demo/run_full.py` | Remove `WebTool()` from tools list |
+| `examples/orchestrator_demo/run_agent.py` | Remove `WebTool()` from tools list |
+| `examples/orchestrator_demo/run_magentic.py` | Remove `WebTool()` from tools list |
+
+### 2.3 MODIFY: Type Definitions
+
+Update `src/utils/models.py`:
+
+```python
+# BEFORE
+sources_searched: list[Literal["pubmed", "web"]]
+
+# AFTER (Phase 9)
+sources_searched: list[Literal["pubmed"]]
+
+# AFTER (Phase 10-11)
+sources_searched: list[Literal["pubmed", "clinicaltrials", "biorxiv"]]
+```
+
+### 2.4 DELETE: Tests for WebTool
+
+```bash
+# File to delete
+tests/unit/tools/test_websearch.py
+```
+
+---
+
+## 3. TDD Implementation
+
+### 3.1 Test: SearchHandler Works Without WebTool
+
+```python
+# tests/unit/tools/test_search_handler.py
+
+@pytest.mark.asyncio
+async def test_search_handler_pubmed_only():
+    """SearchHandler should work with only PubMed tool."""
+    from src.tools.pubmed import PubMedTool
+    from src.tools.search_handler import SearchHandler
+
+    handler = SearchHandler(tools=[PubMedTool()], timeout=30.0)
+
+    # Should not raise
+    result = await handler.execute("metformin diabetes", max_results_per_tool=3)
+
+    assert result.sources_searched == ["pubmed"]
+    assert "web" not in result.sources_searched
+    assert len(result.errors) == 0  # No failures
+```
+
+### 3.2 Test: WebTool Import Fails (Deleted)
+
+```python
+# tests/unit/tools/test_websearch_removed.py
+
+def test_websearch_module_deleted():
+    """WebTool should no longer exist."""
+    with pytest.raises(ImportError):
+        from src.tools.websearch import WebTool
+```
+
+### 3.3 Test: Examples Don't Reference WebTool
+
+```python
+# tests/unit/test_no_webtool_references.py
+
+import ast
+import pathlib
+
+def test_examples_no_webtool_imports():
+    """No example files should import WebTool."""
+    examples_dir = pathlib.Path("examples")
+
+    for py_file in examples_dir.rglob("*.py"):
+        content = py_file.read_text()
+        tree = ast.parse(content)
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom):
+                if node.module and "websearch" in node.module:
+                    pytest.fail(f"{py_file} imports websearch (should be removed)")
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    if "websearch" in alias.name:
+                        pytest.fail(f"{py_file} imports websearch (should be removed)")
+```
+
+---
+
+## 4. Step-by-Step Implementation
+
+### Step 1: Write Tests First (TDD)
+
+```bash
+# Create the test file
+touch tests/unit/tools/test_websearch_removed.py
+# Write the tests from section 3
+```
+
+### Step 2: Run Tests (Should Fail)
+
+```bash
+uv run pytest tests/unit/tools/test_websearch_removed.py -v
+# Expected: FAIL (websearch still exists)
+```
+
+### Step 3: Delete WebTool
+
+```bash
+rm src/tools/websearch.py
+rm tests/unit/tools/test_websearch.py
+```
+
+### Step 4: Update SearchHandler Usages
+
+```python
+# BEFORE (in each example file)
+from src.tools.websearch import WebTool
+search_handler = SearchHandler(tools=[PubMedTool(), WebTool()], timeout=30.0)
+
+# AFTER
+from src.tools.pubmed import PubMedTool
+search_handler = SearchHandler(tools=[PubMedTool()], timeout=30.0)
+```
+
+### Step 5: Update Type Definitions
+
+```python
+# src/utils/models.py
+# BEFORE
+sources_searched: list[Literal["pubmed", "web"]]
+
+# AFTER
+sources_searched: list[Literal["pubmed"]]
+```
+
+### Step 6: Run All Tests
+
+```bash
+uv run pytest tests/unit/ -v
+# Expected: ALL PASS
+```
+
+### Step 7: Run Lints
+
+```bash
+uv run ruff check src tests examples
+uv run mypy src
+# Expected: No errors
+```
+
+---
+
+## 5. Definition of Done
+
+Phase 9 is **COMPLETE** when:
+
+- [ ] `src/tools/websearch.py` deleted
+- [ ] `tests/unit/tools/test_websearch.py` deleted
+- [ ] All example files updated (no WebTool imports)
+- [ ] Type definitions updated in models.py
+- [ ] New tests verify WebTool is removed
+- [ ] All existing tests pass
+- [ ] Lints pass
+- [ ] Examples run successfully with PubMed only
+
+---
+
+## 6. Verification Commands
+
+```bash
+# 1. Verify websearch.py is gone
+ls src/tools/websearch.py 2>&1 | grep "No such file"
+
+# 2. Verify no WebTool imports remain
+grep -r "WebTool" src/ examples/ && echo "FAIL: WebTool references found" || echo "PASS"
+grep -r "websearch" src/ examples/ && echo "FAIL: websearch references found" || echo "PASS"
+
+# 3. Run tests
+uv run pytest tests/unit/ -v
+
+# 4. Run example (should work)
+source .env && uv run python examples/search_demo/run_search.py "metformin cancer"
+```
+
+---
+
+## 7. Rollback Plan
+
+If something breaks:
+
+```bash
+git checkout HEAD -- src/tools/websearch.py
+git checkout HEAD -- tests/unit/tools/test_websearch.py
+```
+
+---
+
+## 8. Value Delivered
+
+| Before | After |
+|--------|-------|
+| 2 search sources (1 broken) | 1 reliable source |
+| Rate limit failures | No failures |
+| Web noise in results | Pure scientific sources |
+| ~230 lines for websearch | 0 lines |
+
+**Net effect**: Simpler, more reliable, more credible.

docs/implementation/10_phase_clinicaltrials.md

@@ -0,0 +1,456 @@
+# Phase 10 Implementation Spec: ClinicalTrials.gov Integration
+
+**Goal**: Add clinical trial search for drug repurposing evidence.
+**Philosophy**: "Clinical trials are the bridge from hypothesis to therapy."
+**Prerequisite**: Phase 9 complete (DuckDuckGo removed)
+**Estimated Time**: 2-3 hours
+
+---
+
+## 1. Why ClinicalTrials.gov?
+
+### Scientific Value
+
+| Feature | Value for Drug Repurposing |
+|---------|---------------------------|
+| **400,000+ studies** | Massive evidence base |
+| **Trial phase data** | Phase I/II/III = evidence strength |
+| **Intervention details** | Exact drug + dosing |
+| **Outcome measures** | What was measured |
+| **Status tracking** | Completed vs recruiting |
+| **Free API** | No cost, no key required |
+
+### Example Query Response
+
+Query: "metformin Alzheimer's"
+
+```json
+{
+  "studies": [
+    {
+      "nctId": "NCT04098666",
+      "briefTitle": "Metformin in Alzheimer's Dementia Prevention",
+      "phase": "Phase 2",
+      "status": "Recruiting",
+      "conditions": ["Alzheimer Disease"],
+      "interventions": ["Drug: Metformin"]
+    }
+  ]
+}
+```
+
+**This is GOLD for drug repurposing** - actual trials testing the hypothesis!
+
+---
+
+## 2. API Specification
+
+### Endpoint
+
+```
+Base URL: https://clinicaltrials.gov/api/v2/studies
+```
+
+### Key Parameters
+
+| Parameter | Description | Example |
+|-----------|-------------|---------|
+| `query.cond` | Condition/disease | `Alzheimer` |
+| `query.intr` | Intervention/drug | `Metformin` |
+| `query.term` | General search | `metformin alzheimer` |
+| `pageSize` | Results per page | `20` |
+| `fields` | Fields to return | See below |
+
+### Fields We Need
+
+```
+NCTId, BriefTitle, Phase, OverallStatus, Condition,
+InterventionName, StartDate, CompletionDate, BriefSummary
+```
+
+### Rate Limits
+
+- ~50 requests/minute per IP
+- No authentication required
+- Paginated (100 results max per call)
+
+### Documentation
+
+- [API v2 Docs](https://clinicaltrials.gov/data-api/api)
+- [Migration Guide](https://www.nlm.nih.gov/pubs/techbull/ma24/ma24_clinicaltrials_api.html)
+
+---
+
+## 3. Data Model
+
+### 3.1 Update Citation Source Type (`src/utils/models.py`)
+
+```python
+# BEFORE
+source: Literal["pubmed", "web"]
+
+# AFTER
+source: Literal["pubmed", "clinicaltrials", "biorxiv"]
+```
+
+### 3.2 Evidence from Clinical Trials
+
+Clinical trial data maps to our existing `Evidence` model:
+
+```python
+Evidence(
+    content=f"{brief_summary}. Phase: {phase}. Status: {status}.",
+    citation=Citation(
+        source="clinicaltrials",
+        title=brief_title,
+        url=f"https://clinicaltrials.gov/study/{nct_id}",
+        date=start_date or "Unknown",
+        authors=[]  # Trials don't have authors in the same way
+    ),
+    relevance=0.8  # Trials are highly relevant for repurposing
+)
+```
+
+---
+
+## 4. Implementation
+
+### 4.1 ClinicalTrials Tool (`src/tools/clinicaltrials.py`)
+
+```python
+"""ClinicalTrials.gov search tool using API v2."""
+
+import httpx
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from src.utils.exceptions import SearchError
+from src.utils.models import Citation, Evidence
+
+
+class ClinicalTrialsTool:
+    """Search tool for ClinicalTrials.gov."""
+
+    BASE_URL = "https://clinicaltrials.gov/api/v2/studies"
+    FIELDS = [
+        "NCTId",
+        "BriefTitle",
+        "Phase",
+        "OverallStatus",
+        "Condition",
+        "InterventionName",
+        "StartDate",
+        "BriefSummary",
+    ]
+
+    @property
+    def name(self) -> str:
+        return "clinicaltrials"
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+        reraise=True,
+    )
+    async def search(self, query: str, max_results: int = 10) -> list[Evidence]:
+        """
+        Search ClinicalTrials.gov for studies.
+
+        Args:
+            query: Search query (e.g., "metformin alzheimer")
+            max_results: Maximum results to return
+
+        Returns:
+            List of Evidence objects from clinical trials
+        """
+        params = {
+            "query.term": query,
+            "pageSize": min(max_results, 100),
+            "fields": "|".join(self.FIELDS),
+        }
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            try:
+                response = await client.get(self.BASE_URL, params=params)
+                response.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                raise SearchError(f"ClinicalTrials.gov search failed: {e}") from e
+
+            data = response.json()
+            studies = data.get("studies", [])
+
+            return [self._study_to_evidence(study) for study in studies[:max_results]]
+
+    def _study_to_evidence(self, study: dict) -> Evidence:
+        """Convert a clinical trial study to Evidence."""
+        # Navigate nested structure
+        protocol = study.get("protocolSection", {})
+        id_module = protocol.get("identificationModule", {})
+        status_module = protocol.get("statusModule", {})
+        desc_module = protocol.get("descriptionModule", {})
+        design_module = protocol.get("designModule", {})
+        conditions_module = protocol.get("conditionsModule", {})
+        arms_module = protocol.get("armsInterventionsModule", {})
+
+        nct_id = id_module.get("nctId", "Unknown")
+        title = id_module.get("briefTitle", "Untitled Study")
+        status = status_module.get("overallStatus", "Unknown")
+        start_date = status_module.get("startDateStruct", {}).get("date", "Unknown")
+
+        # Get phase (might be a list)
+        phases = design_module.get("phases", [])
+        phase = phases[0] if phases else "Not Applicable"
+
+        # Get conditions
+        conditions = conditions_module.get("conditions", [])
+        conditions_str = ", ".join(conditions[:3]) if conditions else "Unknown"
+
+        # Get interventions
+        interventions = arms_module.get("interventions", [])
+        intervention_names = [i.get("name", "") for i in interventions[:3]]
+        interventions_str = ", ".join(intervention_names) if intervention_names else "Unknown"
+
+        # Get summary
+        summary = desc_module.get("briefSummary", "No summary available.")
+
+        # Build content with key trial info
+        content = (
+            f"{summary[:500]}... "
+            f"Trial Phase: {phase}. "
+            f"Status: {status}. "
+            f"Conditions: {conditions_str}. "
+            f"Interventions: {interventions_str}."
+        )
+
+        return Evidence(
+            content=content[:2000],
+            citation=Citation(
+                source="clinicaltrials",
+                title=title[:500],
+                url=f"https://clinicaltrials.gov/study/{nct_id}",
+                date=start_date,
+                authors=[],  # Trials don't have traditional authors
+            ),
+            relevance=0.85,  # Trials are highly relevant for repurposing
+        )
+```
+
+---
+
+## 5. TDD Test Suite
+
+### 5.1 Unit Tests (`tests/unit/tools/test_clinicaltrials.py`)
+
+```python
+"""Unit tests for ClinicalTrials.gov tool."""
+
+import pytest
+import respx
+from httpx import Response
+
+from src.tools.clinicaltrials import ClinicalTrialsTool
+from src.utils.models import Evidence
+
+
+@pytest.fixture
+def mock_clinicaltrials_response():
+    """Mock ClinicalTrials.gov API response."""
+    return {
+        "studies": [
+            {
+                "protocolSection": {
+                    "identificationModule": {
+                        "nctId": "NCT04098666",
+                        "briefTitle": "Metformin in Alzheimer's Dementia Prevention"
+                    },
+                    "statusModule": {
+                        "overallStatus": "Recruiting",
+                        "startDateStruct": {"date": "2020-01-15"}
+                    },
+                    "descriptionModule": {
+                        "briefSummary": "This study evaluates metformin for Alzheimer's prevention."
+                    },
+                    "designModule": {
+                        "phases": ["PHASE2"]
+                    },
+                    "conditionsModule": {
+                        "conditions": ["Alzheimer Disease", "Dementia"]
+                    },
+                    "armsInterventionsModule": {
+                        "interventions": [
+                            {"name": "Metformin", "type": "Drug"}
+                        ]
+                    }
+                }
+            }
+        ]
+    }
+
+
+class TestClinicalTrialsTool:
+    """Tests for ClinicalTrialsTool."""
+
+    def test_tool_name(self):
+        """Tool should have correct name."""
+        tool = ClinicalTrialsTool()
+        assert tool.name == "clinicaltrials"
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_returns_evidence(self, mock_clinicaltrials_response):
+        """Search should return Evidence objects."""
+        respx.get("https://clinicaltrials.gov/api/v2/studies").mock(
+            return_value=Response(200, json=mock_clinicaltrials_response)
+        )
+
+        tool = ClinicalTrialsTool()
+        results = await tool.search("metformin alzheimer", max_results=5)
+
+        assert len(results) == 1
+        assert isinstance(results[0], Evidence)
+        assert results[0].citation.source == "clinicaltrials"
+        assert "NCT04098666" in results[0].citation.url
+        assert "Metformin" in results[0].citation.title
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_extracts_phase(self, mock_clinicaltrials_response):
+        """Search should extract trial phase."""
+        respx.get("https://clinicaltrials.gov/api/v2/studies").mock(
+            return_value=Response(200, json=mock_clinicaltrials_response)
+        )
+
+        tool = ClinicalTrialsTool()
+        results = await tool.search("metformin alzheimer")
+
+        assert "PHASE2" in results[0].content
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_extracts_status(self, mock_clinicaltrials_response):
+        """Search should extract trial status."""
+        respx.get("https://clinicaltrials.gov/api/v2/studies").mock(
+            return_value=Response(200, json=mock_clinicaltrials_response)
+        )
+
+        tool = ClinicalTrialsTool()
+        results = await tool.search("metformin alzheimer")
+
+        assert "Recruiting" in results[0].content
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_empty_results(self):
+        """Search should handle empty results gracefully."""
+        respx.get("https://clinicaltrials.gov/api/v2/studies").mock(
+            return_value=Response(200, json={"studies": []})
+        )
+
+        tool = ClinicalTrialsTool()
+        results = await tool.search("nonexistent query xyz")
+
+        assert results == []
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_api_error(self):
+        """Search should raise SearchError on API failure."""
+        from src.utils.exceptions import SearchError
+
+        respx.get("https://clinicaltrials.gov/api/v2/studies").mock(
+            return_value=Response(500, text="Internal Server Error")
+        )
+
+        tool = ClinicalTrialsTool()
+
+        with pytest.raises(SearchError):
+            await tool.search("metformin alzheimer")
+
+
+class TestClinicalTrialsIntegration:
+    """Integration tests (marked for separate run)."""
+
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_real_api_call(self):
+        """Test actual API call (requires network)."""
+        tool = ClinicalTrialsTool()
+        results = await tool.search("metformin diabetes", max_results=3)
+
+        assert len(results) > 0
+        assert all(isinstance(r, Evidence) for r in results)
+        assert all(r.citation.source == "clinicaltrials" for r in results)
+```
+
+---
+
+## 6. Integration with SearchHandler
+
+### 6.1 Update Example Files
+
+```python
+# examples/search_demo/run_search.py
+from src.tools.clinicaltrials import ClinicalTrialsTool
+from src.tools.pubmed import PubMedTool
+from src.tools.search_handler import SearchHandler
+
+search_handler = SearchHandler(
+    tools=[PubMedTool(), ClinicalTrialsTool()],
+    timeout=30.0
+)
+```
+
+### 6.2 Update SearchResult Type
+
+```python
+# src/utils/models.py
+sources_searched: list[Literal["pubmed", "clinicaltrials"]]
+```
+
+---
+
+## 7. Definition of Done
+
+Phase 10 is **COMPLETE** when:
+
+- [ ] `src/tools/clinicaltrials.py` implemented
+- [ ] Unit tests in `tests/unit/tools/test_clinicaltrials.py`
+- [ ] Integration test marked with `@pytest.mark.integration`
+- [ ] SearchHandler updated to include ClinicalTrialsTool
+- [ ] Type definitions updated in models.py
+- [ ] Example files updated
+- [ ] All unit tests pass
+- [ ] Lints pass
+- [ ] Manual verification with real API
+
+---
+
+## 8. Verification Commands
+
+```bash
+# 1. Run unit tests
+uv run pytest tests/unit/tools/test_clinicaltrials.py -v
+
+# 2. Run integration test (requires network)
+uv run pytest tests/unit/tools/test_clinicaltrials.py -v -m integration
+
+# 3. Run full test suite
+uv run pytest tests/unit/ -v
+
+# 4. Run example
+source .env && uv run python examples/search_demo/run_search.py "metformin alzheimer"
+# Should show results from BOTH PubMed AND ClinicalTrials.gov
+```
+
+---
+
+## 9. Value Delivered
+
+| Before | After |
+|--------|-------|
+| Papers only | Papers + Clinical Trials |
+| "Drug X might help" | "Drug X is in Phase II trial" |
+| No trial status | Recruiting/Completed/Terminated |
+| No phase info | Phase I/II/III evidence strength |
+
+**Demo pitch addition**:
+> "DeepCritical searches PubMed for peer-reviewed evidence AND ClinicalTrials.gov for 400,000+ clinical trials."

docs/implementation/11_phase_biorxiv.md

@@ -0,0 +1,572 @@
+# Phase 11 Implementation Spec: bioRxiv Preprint Integration
+
+**Goal**: Add cutting-edge preprint search for the latest research.
+**Philosophy**: "Preprints are where breakthroughs appear first."
+**Prerequisite**: Phase 10 complete (ClinicalTrials.gov working)
+**Estimated Time**: 2-3 hours
+
+---
+
+## 1. Why bioRxiv?
+
+### Scientific Value
+
+| Feature | Value for Drug Repurposing |
+|---------|---------------------------|
+| **Cutting-edge research** | 6-12 months ahead of PubMed |
+| **Rapid publication** | Days, not months |
+| **Free full-text** | Complete papers, not just abstracts |
+| **medRxiv included** | Medical preprints via same API |
+| **No API key required** | Free and open |
+
+### The Preprint Advantage
+
+```
+Traditional Publication Timeline:
+  Research → Submit → Review → Revise → Accept → Publish
+  |___________________________ 6-18 months _______________|
+
+Preprint Timeline:
+  Research → Upload → Available
+  |______ 1-3 days ______|
+```
+
+**For drug repurposing**: Preprints contain the newest hypotheses and evidence!
+
+---
+
+## 2. API Specification
+
+### Endpoint
+
+```
+Base URL: https://api.biorxiv.org/details/[server]/[interval]/[cursor]/[format]
+```
+
+### Servers
+
+| Server | Content |
+|--------|---------|
+| `biorxiv` | Biology preprints |
+| `medrxiv` | Medical preprints (more relevant for us!) |
+
+### Interval Formats
+
+| Format | Example | Description |
+|--------|---------|-------------|
+| Date range | `2024-01-01/2024-12-31` | Papers between dates |
+| Recent N | `50` | Most recent N papers |
+| Recent N days | `30d` | Papers from last N days |
+
+### Response Format
+
+```json
+{
+  "collection": [
+    {
+      "doi": "10.1101/2024.01.15.123456",
+      "title": "Metformin repurposing for neurodegeneration",
+      "authors": "Smith, J; Jones, A",
+      "date": "2024-01-15",
+      "category": "neuroscience",
+      "abstract": "We investigated metformin's potential..."
+    }
+  ],
+  "messages": [{"status": "ok", "count": 100}]
+}
+```
+
+### Rate Limits
+
+- No official limit, but be respectful
+- Results paginated (100 per call)
+- Use cursor for pagination
+
+### Documentation
+
+- [bioRxiv API](https://api.biorxiv.org/)
+- [medrxivr R package docs](https://docs.ropensci.org/medrxivr/)
+
+---
+
+## 3. Search Strategy
+
+### Challenge: bioRxiv API Limitations
+
+The bioRxiv API does NOT support keyword search directly. It returns papers by:
+- Date range
+- Recent count
+
+### Solution: Client-Side Filtering
+
+```python
+# Strategy:
+# 1. Fetch recent papers (e.g., last 90 days)
+# 2. Filter by keyword matching in title/abstract
+# 3. Use embeddings for semantic matching (leverage Phase 6!)
+```
+
+### Alternative: Content Search Endpoint
+
+```
+https://api.biorxiv.org/pubs/[server]/[doi_prefix]
+```
+
+For searching, we can use the publisher endpoint with filtering.
+
+---
+
+## 4. Data Model
+
+### 4.1 Update Citation Source Type (`src/utils/models.py`)
+
+```python
+# After Phase 11
+source: Literal["pubmed", "clinicaltrials", "biorxiv"]
+```
+
+### 4.2 Evidence from Preprints
+
+```python
+Evidence(
+    content=abstract[:2000],
+    citation=Citation(
+        source="biorxiv",  # or "medrxiv"
+        title=title,
+        url=f"https://doi.org/{doi}",
+        date=date,
+        authors=authors.split("; ")[:5]
+    ),
+    relevance=0.75  # Preprints slightly lower than peer-reviewed
+)
+```
+
+---
+
+## 5. Implementation
+
+### 5.1 bioRxiv Tool (`src/tools/biorxiv.py`)
+
+```python
+"""bioRxiv/medRxiv preprint search tool."""
+
+import re
+from datetime import datetime, timedelta
+
+import httpx
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from src.utils.exceptions import SearchError
+from src.utils.models import Citation, Evidence
+
+
+class BioRxivTool:
+    """Search tool for bioRxiv and medRxiv preprints."""
+
+    BASE_URL = "https://api.biorxiv.org/details"
+    # Use medRxiv for medical/clinical content (more relevant for drug repurposing)
+    DEFAULT_SERVER = "medrxiv"
+    # Fetch papers from last N days
+    DEFAULT_DAYS = 90
+
+    def __init__(self, server: str = DEFAULT_SERVER, days: int = DEFAULT_DAYS):
+        """
+        Initialize bioRxiv tool.
+
+        Args:
+            server: "biorxiv" or "medrxiv"
+            days: How many days back to search
+        """
+        self.server = server
+        self.days = days
+
+    @property
+    def name(self) -> str:
+        return "biorxiv"
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+        reraise=True,
+    )
+    async def search(self, query: str, max_results: int = 10) -> list[Evidence]:
+        """
+        Search bioRxiv/medRxiv for preprints matching query.
+
+        Note: bioRxiv API doesn't support keyword search directly.
+        We fetch recent papers and filter client-side.
+
+        Args:
+            query: Search query (keywords)
+            max_results: Maximum results to return
+
+        Returns:
+            List of Evidence objects from preprints
+        """
+        # Build date range for last N days
+        end_date = datetime.now().strftime("%Y-%m-%d")
+        start_date = (datetime.now() - timedelta(days=self.days)).strftime("%Y-%m-%d")
+        interval = f"{start_date}/{end_date}"
+
+        # Fetch recent papers
+        url = f"{self.BASE_URL}/{self.server}/{interval}/0/json"
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            try:
+                response = await client.get(url)
+                response.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                raise SearchError(f"bioRxiv search failed: {e}") from e
+
+            data = response.json()
+            papers = data.get("collection", [])
+
+            # Filter papers by query keywords
+            query_terms = self._extract_terms(query)
+            matching = self._filter_by_keywords(papers, query_terms, max_results)
+
+            return [self._paper_to_evidence(paper) for paper in matching]
+
+    def _extract_terms(self, query: str) -> list[str]:
+        """Extract search terms from query."""
+        # Simple tokenization, lowercase
+        terms = re.findall(r'\b\w+\b', query.lower())
+        # Filter out common stop words
+        stop_words = {'the', 'a', 'an', 'in', 'on', 'for', 'and', 'or', 'of', 'to'}
+        return [t for t in terms if t not in stop_words and len(t) > 2]
+
+    def _filter_by_keywords(
+        self, papers: list[dict], terms: list[str], max_results: int
+    ) -> list[dict]:
+        """Filter papers that contain query terms in title or abstract."""
+        scored_papers = []
+
+        for paper in papers:
+            title = paper.get("title", "").lower()
+            abstract = paper.get("abstract", "").lower()
+            text = f"{title} {abstract}"
+
+            # Count matching terms
+            matches = sum(1 for term in terms if term in text)
+
+            if matches > 0:
+                scored_papers.append((matches, paper))
+
+        # Sort by match count (descending)
+        scored_papers.sort(key=lambda x: x[0], reverse=True)
+
+        return [paper for _, paper in scored_papers[:max_results]]
+
+    def _paper_to_evidence(self, paper: dict) -> Evidence:
+        """Convert a preprint paper to Evidence."""
+        doi = paper.get("doi", "")
+        title = paper.get("title", "Untitled")
+        authors_str = paper.get("authors", "Unknown")
+        date = paper.get("date", "Unknown")
+        abstract = paper.get("abstract", "No abstract available.")
+        category = paper.get("category", "")
+
+        # Parse authors (format: "Smith, J; Jones, A")
+        authors = [a.strip() for a in authors_str.split(";")][:5]
+
+        # Note this is a preprint in the content
+        content = (
+            f"[PREPRINT - Not peer-reviewed] "
+            f"{abstract[:1800]}... "
+            f"Category: {category}."
+        )
+
+        return Evidence(
+            content=content[:2000],
+            citation=Citation(
+                source="biorxiv",
+                title=title[:500],
+                url=f"https://doi.org/{doi}" if doi else f"https://www.medrxiv.org/",
+                date=date,
+                authors=authors,
+            ),
+            relevance=0.75,  # Slightly lower than peer-reviewed
+        )
+```
+
+---
+
+## 6. TDD Test Suite
+
+### 6.1 Unit Tests (`tests/unit/tools/test_biorxiv.py`)
+
+```python
+"""Unit tests for bioRxiv tool."""
+
+import pytest
+import respx
+from httpx import Response
+
+from src.tools.biorxiv import BioRxivTool
+from src.utils.models import Evidence
+
+
+@pytest.fixture
+def mock_biorxiv_response():
+    """Mock bioRxiv API response."""
+    return {
+        "collection": [
+            {
+                "doi": "10.1101/2024.01.15.24301234",
+                "title": "Metformin repurposing for Alzheimer's disease: a systematic review",
+                "authors": "Smith, John; Jones, Alice; Brown, Bob",
+                "date": "2024-01-15",
+                "category": "neurology",
+                "abstract": "Background: Metformin has shown neuroprotective effects. "
+                           "We conducted a systematic review of metformin's potential "
+                           "for Alzheimer's disease treatment."
+            },
+            {
+                "doi": "10.1101/2024.01.10.24301111",
+                "title": "COVID-19 vaccine efficacy study",
+                "authors": "Wilson, C",
+                "date": "2024-01-10",
+                "category": "infectious diseases",
+                "abstract": "This study evaluates COVID-19 vaccine efficacy."
+            }
+        ],
+        "messages": [{"status": "ok", "count": 2}]
+    }
+
+
+class TestBioRxivTool:
+    """Tests for BioRxivTool."""
+
+    def test_tool_name(self):
+        """Tool should have correct name."""
+        tool = BioRxivTool()
+        assert tool.name == "biorxiv"
+
+    def test_default_server_is_medrxiv(self):
+        """Default server should be medRxiv for medical relevance."""
+        tool = BioRxivTool()
+        assert tool.server == "medrxiv"
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_returns_evidence(self, mock_biorxiv_response):
+        """Search should return Evidence objects."""
+        respx.get(url__startswith="https://api.biorxiv.org/details").mock(
+            return_value=Response(200, json=mock_biorxiv_response)
+        )
+
+        tool = BioRxivTool()
+        results = await tool.search("metformin alzheimer", max_results=5)
+
+        assert len(results) == 1  # Only the matching paper
+        assert isinstance(results[0], Evidence)
+        assert results[0].citation.source == "biorxiv"
+        assert "metformin" in results[0].citation.title.lower()
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_filters_by_keywords(self, mock_biorxiv_response):
+        """Search should filter papers by query keywords."""
+        respx.get(url__startswith="https://api.biorxiv.org/details").mock(
+            return_value=Response(200, json=mock_biorxiv_response)
+        )
+
+        tool = BioRxivTool()
+
+        # Search for metformin - should match first paper
+        results = await tool.search("metformin")
+        assert len(results) == 1
+        assert "metformin" in results[0].citation.title.lower()
+
+        # Search for COVID - should match second paper
+        results = await tool.search("covid vaccine")
+        assert len(results) == 1
+        assert "covid" in results[0].citation.title.lower()
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_marks_as_preprint(self, mock_biorxiv_response):
+        """Evidence content should note it's a preprint."""
+        respx.get(url__startswith="https://api.biorxiv.org/details").mock(
+            return_value=Response(200, json=mock_biorxiv_response)
+        )
+
+        tool = BioRxivTool()
+        results = await tool.search("metformin")
+
+        assert "PREPRINT" in results[0].content
+        assert "Not peer-reviewed" in results[0].content
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_empty_results(self):
+        """Search should handle empty results gracefully."""
+        respx.get(url__startswith="https://api.biorxiv.org/details").mock(
+            return_value=Response(200, json={"collection": [], "messages": []})
+        )
+
+        tool = BioRxivTool()
+        results = await tool.search("xyznonexistent")
+
+        assert results == []
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_search_api_error(self):
+        """Search should raise SearchError on API failure."""
+        from src.utils.exceptions import SearchError
+
+        respx.get(url__startswith="https://api.biorxiv.org/details").mock(
+            return_value=Response(500, text="Internal Server Error")
+        )
+
+        tool = BioRxivTool()
+
+        with pytest.raises(SearchError):
+            await tool.search("metformin")
+
+    def test_extract_terms(self):
+        """Should extract meaningful search terms."""
+        tool = BioRxivTool()
+
+        terms = tool._extract_terms("metformin for Alzheimer's disease")
+
+        assert "metformin" in terms
+        assert "alzheimer" in terms
+        assert "disease" in terms
+        assert "for" not in terms  # Stop word
+        assert "the" not in terms  # Stop word
+
+
+class TestBioRxivIntegration:
+    """Integration tests (marked for separate run)."""
+
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_real_api_call(self):
+        """Test actual API call (requires network)."""
+        tool = BioRxivTool(days=30)  # Last 30 days
+        results = await tool.search("diabetes", max_results=3)
+
+        # May or may not find results depending on recent papers
+        assert isinstance(results, list)
+        for r in results:
+            assert isinstance(r, Evidence)
+            assert r.citation.source == "biorxiv"
+```
+
+---
+
+## 7. Integration with SearchHandler
+
+### 7.1 Final SearchHandler Configuration
+
+```python
+# examples/search_demo/run_search.py
+from src.tools.biorxiv import BioRxivTool
+from src.tools.clinicaltrials import ClinicalTrialsTool
+from src.tools.pubmed import PubMedTool
+from src.tools.search_handler import SearchHandler
+
+search_handler = SearchHandler(
+    tools=[
+        PubMedTool(),           # Peer-reviewed papers
+        ClinicalTrialsTool(),   # Clinical trials
+        BioRxivTool(),          # Preprints (cutting edge)
+    ],
+    timeout=30.0
+)
+```
+
+### 7.2 Final Type Definition
+
+```python
+# src/utils/models.py
+sources_searched: list[Literal["pubmed", "clinicaltrials", "biorxiv"]]
+```
+
+---
+
+## 8. Definition of Done
+
+Phase 11 is **COMPLETE** when:
+
+- [ ] `src/tools/biorxiv.py` implemented
+- [ ] Unit tests in `tests/unit/tools/test_biorxiv.py`
+- [ ] Integration test marked with `@pytest.mark.integration`
+- [ ] SearchHandler updated to include BioRxivTool
+- [ ] Type definitions updated in models.py
+- [ ] Example files updated
+- [ ] All unit tests pass
+- [ ] Lints pass
+- [ ] Manual verification with real API
+
+---
+
+## 9. Verification Commands
+
+```bash
+# 1. Run unit tests
+uv run pytest tests/unit/tools/test_biorxiv.py -v
+
+# 2. Run integration test (requires network)
+uv run pytest tests/unit/tools/test_biorxiv.py -v -m integration
+
+# 3. Run full test suite
+uv run pytest tests/unit/ -v
+
+# 4. Run example with all three sources
+source .env && uv run python examples/search_demo/run_search.py "metformin diabetes"
+# Should show results from PubMed, ClinicalTrials.gov, AND bioRxiv/medRxiv
+```
+
+---
+
+## 10. Value Delivered
+
+| Before | After |
+|--------|-------|
+| Only published papers | Published + Preprints |
+| 6-18 month lag | Near real-time research |
+| Miss cutting-edge | Catch breakthroughs early |
+
+**Demo pitch (final)**:
+> "DeepCritical searches PubMed for peer-reviewed evidence, ClinicalTrials.gov for 400,000+ clinical trials, and bioRxiv/medRxiv for cutting-edge preprints - then uses LLMs to generate mechanistic hypotheses and synthesize findings into publication-quality reports."
+
+---
+
+## 11. Complete Source Architecture (After Phase 11)
+
+```
+User Query: "Can metformin treat Alzheimer's?"
+                    |
+                    v
+            SearchHandler
+                    |
+    ┌───────────────┼───────────────┐
+    |               |               |
+    v               v               v
+PubMedTool    ClinicalTrials   BioRxivTool
+    |          Tool               |
+    |               |               |
+    v               v               v
+"15 peer-    "3 Phase II     "2 preprints
+reviewed      trials          from last
+papers"       recruiting"     90 days"
+    |               |               |
+    └───────────────┼───────────────┘
+                    |
+                    v
+            Evidence Pool
+                    |
+                    v
+        EmbeddingService.deduplicate()
+                    |
+                    v
+        HypothesisAgent → JudgeAgent → ReportAgent
+                    |
+                    v
+        Structured Research Report
+```
+
+**This is the Gucci Banger stack.**

docs/implementation/roadmap.md

@@ -188,9 +188,12 @@ Structured Research Report
 3. **[Phase 3 Spec: Judge Slice](03_phase_judge.md)** ✅
 4. **[Phase 4 Spec: UI & Loop](04_phase_ui.md)** ✅
 5. **[Phase 5 Spec: Magentic Integration](05_phase_magentic.md)** ✅
-6. **[Phase 6 Spec: Embeddings & Semantic Search](06_phase_embeddings.md)**
-7. **[Phase 7 Spec: Hypothesis Agent](07_phase_hypothesis.md)**
-8. **[Phase 8 Spec: Report Agent](08_phase_report.md)**
+6. **[Phase 6 Spec: Embeddings & Semantic Search](06_phase_embeddings.md)** ✅
+7. **[Phase 7 Spec: Hypothesis Agent](07_phase_hypothesis.md)** ✅
+8. **[Phase 8 Spec: Report Agent](08_phase_report.md)** ✅
+9. **[Phase 9 Spec: Remove DuckDuckGo](09_phase_source_cleanup.md)** 📝
+10. **[Phase 10 Spec: ClinicalTrials.gov](10_phase_clinicaltrials.md)** 📝
+11. **[Phase 11 Spec: bioRxiv Preprints](11_phase_biorxiv.md)** 📝
 
 ---
 
@@ -203,8 +206,11 @@ Structured Research Report
 | Phase 3: Judge | ✅ COMPLETE | LLM evidence assessment |
 | Phase 4: UI & Loop | ✅ COMPLETE | Working Gradio app |
 | Phase 5: Magentic | ✅ COMPLETE | Multi-agent orchestration |
-| Phase 6: Embeddings | 📝 SPEC READY | Semantic search |
-| Phase 7: Hypothesis | 📝 SPEC READY | Mechanistic reasoning |
-| Phase 8: Report | 📝 SPEC READY | Structured reports |
-
-*Phases 1-5 completed in ONE DAY. Phases 6-8 specs ready for implementation.*
+| Phase 6: Embeddings | ✅ COMPLETE | Semantic search + ChromaDB |
+| Phase 7: Hypothesis | ✅ COMPLETE | Mechanistic reasoning chains |
+| Phase 8: Report | ✅ COMPLETE | Structured scientific reports |
+| Phase 9: Source Cleanup | 📝 SPEC READY | Remove DuckDuckGo |
+| Phase 10: ClinicalTrials | 📝 SPEC READY | ClinicalTrials.gov API |
+| Phase 11: bioRxiv | 📝 SPEC READY | Preprint search |
+
+*Phases 1-8 COMPLETE. Phases 9-11 will add multi-source credibility.*

docs/index.md

@@ -14,10 +14,17 @@ AI-powered deep research system for accelerating drug repurposing discovery.
 
 ### Implementation (Start Here!)
 - **[Roadmap](implementation/roadmap.md)** - Phased execution plan with TDD
-- **[Phase 1: Foundation](implementation/01_phase_foundation.md)** - Tooling, config, first tests
-- **[Phase 2: Search](implementation/02_phase_search.md)** - PubMed + DuckDuckGo
-- **[Phase 3: Judge](implementation/03_phase_judge.md)** - LLM evidence assessment
-- **[Phase 4: UI](implementation/04_phase_ui.md)** - Orchestrator + Gradio + Deploy
+- **[Phase 1: Foundation](implementation/01_phase_foundation.md)** ✅ - Tooling, config, first tests
+- **[Phase 2: Search](implementation/02_phase_search.md)** ✅ - PubMed search
+- **[Phase 3: Judge](implementation/03_phase_judge.md)** ✅ - LLM evidence assessment
+- **[Phase 4: UI](implementation/04_phase_ui.md)** ✅ - Orchestrator + Gradio
+- **[Phase 5: Magentic](implementation/05_phase_magentic.md)** ✅ - Multi-agent orchestration
+- **[Phase 6: Embeddings](implementation/06_phase_embeddings.md)** ✅ - Semantic search + dedup
+- **[Phase 7: Hypothesis](implementation/07_phase_hypothesis.md)** ✅ - Mechanistic reasoning
+- **[Phase 8: Report](implementation/08_phase_report.md)** ✅ - Structured scientific reports
+- **[Phase 9: Source Cleanup](implementation/09_phase_source_cleanup.md)** 📝 - Remove DuckDuckGo
+- **[Phase 10: ClinicalTrials](implementation/10_phase_clinicaltrials.md)** 📝 - Clinical trials API
+- **[Phase 11: bioRxiv](implementation/11_phase_biorxiv.md)** 📝 - Preprint search
 
 ### Guides
 - [Setup Guide](guides/setup.md) (coming soon)
@@ -76,6 +83,13 @@ User Question → Research Agent (Orchestrator)
 
 ## Status
 
+| Phase | Status |
+|-------|--------|
+| Phases 1-8 | ✅ COMPLETE |
+| Phase 9: Remove DuckDuckGo | 📝 SPEC READY |
+| Phase 10: ClinicalTrials.gov | 📝 SPEC READY |
+| Phase 11: bioRxiv | 📝 SPEC READY |
+
 **Architecture Review**: PASSED (98-99/100)
-**Specs**: IRONCLAD
-**Next**: Implementation
+**Phases 1-8**: COMPLETE
+**Next**: Phases 9-11 (Multi-Source Enhancement)