fix(phase2): address CodeRabbit review feedback + add examples

CodeRabbit fixes:
- Fix deprecated asyncio.get_event_loop() → get_running_loop()
- Remove dead flatten() function from search_handler.py
- Remove redundant getattr() in pubmed.py
- Add truncation rationale comments

New:
- Add examples/search_demo/ with run_search.py demo script
- Add examples/README.md

examples/README.md

@@ -0,0 +1,23 @@
+# Examples
+
+Demo scripts for DeepCritical functionality.
+
+## search_demo
+
+Demonstrates Phase 2 search functionality:
+
+```bash
+# Run with default query (metformin + Alzheimer's)
+uv run python examples/search_demo/run_search.py
+
+# Run with custom query
+uv run python examples/search_demo/run_search.py "aspirin heart disease"
+```
+
+**What it does:**
+- Searches PubMed (biomedical literature)
+- Searches DuckDuckGo (web)
+- Runs both in parallel (scatter-gather)
+- Returns evidence with citations
+
+**Optional:** Set `NCBI_API_KEY` in `.env` for higher PubMed rate limits.

examples/search_demo/run_search.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+Demo: Search for drug repurposing evidence.
+
+This script demonstrates Phase 2 functionality:
+- PubMed search (biomedical literature)
+- Web search (DuckDuckGo)
+- SearchHandler (parallel scatter-gather orchestration)
+
+Usage:
+    # From project root:
+    uv run python examples/search_demo/run_search.py
+
+    # With custom query:
+    uv run python examples/search_demo/run_search.py "metformin cancer"
+
+Requirements:
+    - Optional: NCBI_API_KEY in .env for higher PubMed rate limits
+"""
+
+import asyncio
+import sys
+
+from src.tools.pubmed import PubMedTool
+from src.tools.search_handler import SearchHandler
+from src.tools.websearch import WebTool
+
+
+async def main(query: str) -> None:
+    """Run search demo with the given query."""
+    print(f"\n{'='*60}")
+    print("DeepCritical Search Demo")
+    print(f"Query: {query}")
+    print(f"{'='*60}\n")
+
+    # Initialize tools
+    pubmed = PubMedTool()
+    web = WebTool()
+    handler = SearchHandler(tools=[pubmed, web], timeout=30.0)
+
+    # Execute search
+    print("Searching PubMed and Web in parallel...")
+    result = await handler.execute(query, max_results_per_tool=5)
+
+    # Display results
+    print(f"\n{'='*60}")
+    print(f"Results: {result.total_found} pieces of evidence")
+    print(f"Sources: {', '.join(result.sources_searched)}")
+    if result.errors:
+        print(f"Errors: {result.errors}")
+    print(f"{'='*60}\n")
+
+    for i, evidence in enumerate(result.evidence, 1):
+        print(f"[{i}] {evidence.citation.source.upper()}: {evidence.citation.title[:80]}...")
+        print(f"    URL: {evidence.citation.url}")
+        print(f"    Content: {evidence.content[:150]}...")
+        print()
+
+
+if __name__ == "__main__":
+    # Default query or use command line arg
+    default_query = "metformin Alzheimer's disease drug repurposing"
+    query = sys.argv[1] if len(sys.argv) > 1 else default_query
+
+    asyncio.run(main(query))

src/tools/pubmed.py

@@ -20,7 +20,7 @@ class PubMedTool:
     HTTP_TOO_MANY_REQUESTS = 429
 
     def __init__(self, api_key: str | None = None) -> None:
-        self.api_key = api_key or getattr(settings, "ncbi_api_key", None)
+        self.api_key = api_key or settings.ncbi_api_key
         self._last_request_time = 0.0
 
     @property
@@ -29,11 +29,12 @@ class PubMedTool:
 
     async def _rate_limit(self) -> None:
         """Enforce NCBI rate limiting."""
-        now = asyncio.get_event_loop().time()
+        loop = asyncio.get_running_loop()
+        now = loop.time()
         elapsed = now - self._last_request_time
         if elapsed < self.RATE_LIMIT_DELAY:
             await asyncio.sleep(self.RATE_LIMIT_DELAY - elapsed)
-        self._last_request_time = asyncio.get_event_loop().time()
+        self._last_request_time = loop.time()
 
     def _build_params(self, **kwargs: Any) -> dict[str, Any]:
         """Build request params with optional API key."""
@@ -174,8 +175,11 @@ class PubMedTool:
             if last:
                 authors.append(f"{last} {first}".strip())
 
+        # Truncation rationale: LLM context limits + cost optimization
+        # - Abstract: 2000 chars (~500 tokens) captures key findings
+        # - Title: 500 chars covers even verbose journal titles
         return Evidence(
-            content=abstract[:2000],  # Truncate long abstracts
+            content=abstract[:2000],
             citation=Citation(
                 source="pubmed",
                 title=title[:500],

src/tools/search_handler.py

@@ -12,11 +12,6 @@ from src.utils.models import Evidence, SearchResult
 logger = structlog.get_logger()
 
 
-def flatten(nested: list[list[Evidence]]) -> list[Evidence]:
-    """Flatten a list of lists into a single list."""
-    return [item for sublist in nested for item in sublist]
-
-
 class SearchHandler:
     """Orchestrates parallel searches across multiple tools."""
 

src/tools/websearch.py

@@ -25,7 +25,7 @@ class WebTool:
 
         Note: duckduckgo-search is synchronous, so we run it in executor.
         """
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         try:
             results = await loop.run_in_executor(
                 None,
@@ -42,6 +42,9 @@ class WebTool:
         with DDGS() as ddgs:
             results: list[dict[str, Any]] = list(ddgs.text(query, max_results=max_results))
 
+        # Truncation rationale: LLM context limits + cost optimization
+        # - Content: 1000 chars (~250 tokens) - web snippets are shorter than abstracts
+        # - Title: 500 chars covers most web page titles
         for result in results:
             evidence_list.append(
                 Evidence(