feat(clinicaltrials): SPEC_14 Outcome Measures (#100)

* feat: add outcome measures to ClinicalTrials.gov tool

- Add OutcomesModule and HasResults to FIELDS constant
- Extract primary outcomes with measure and timeFrame
- Show results availability status with posted date
- Boost relevance for trials with results (0.90 vs 0.85)
- Add 4 unit tests per SPEC_14

Closes #95

* fix: address CodeRabbit review feedback for SPEC_14

- Fix unconditional ellipsis: Only add "..." when summary > 400 chars
- Refine primary outcome truncation: Build full string before truncating
- Extract _extract_primary_outcome() helper to reduce statement count
- Add identificationModule to test mock for completeness

Addresses review comments on PR #100.

* test: add pytest.skip for API flakiness resilience

Add defensive skip if ClinicalTrials.gov API returns no results,
making the integration test more resilient to external API changes.

Addresses CodeRabbit review feedback on PR #100.

src/tools/clinicaltrials.py

@@ -30,6 +30,9 @@ class ClinicalTrialsTool:
         "InterventionName",
         "StartDate",
         "BriefSummary",
+        # NEW: Outcome measures
+        "OutcomesModule",
+        "HasResults",
     ]
 
     # Status filter: Only active/completed studies with potential data
@@ -89,6 +92,20 @@ class ClinicalTrialsTool:
         except requests.RequestException as e:
             raise SearchError(f"ClinicalTrials.gov request failed: {e}") from e
 
+    def _extract_primary_outcome(self, outcomes_module: dict[str, Any]) -> str:
+        """Extract and format primary outcome from outcomes module."""
+        primary_outcomes = outcomes_module.get("primaryOutcomes", [])
+        if not primary_outcomes:
+            return ""
+        # Get first primary outcome measure and timeframe
+        first = primary_outcomes[0]
+        measure = first.get("measure", "")
+        timeframe = first.get("timeFrame", "")
+        # Build full outcome string first, then truncate
+        result = f"{measure} (measured at {timeframe})" if timeframe else measure
+        # Truncate long outcome descriptions with ellipsis
+        return result[:197] + "..." if len(result) > 200 else result
+
     def _study_to_evidence(self, study: dict[str, Any]) -> Evidence:
         """Convert a clinical trial study to Evidence."""
         # Navigate nested structure
@@ -99,6 +116,7 @@ class ClinicalTrialsTool:
         design_module = protocol.get("designModule", {})
         conditions_module = protocol.get("conditionsModule", {})
         arms_module = protocol.get("armsInterventionsModule", {})
+        outcomes_module = protocol.get("outcomesModule", {})
 
         nct_id = id_module.get("nctId", "Unknown")
         title = id_module.get("briefTitle", "Untitled Study")
@@ -121,14 +139,42 @@ class ClinicalTrialsTool:
         # Get summary
         summary = desc_module.get("briefSummary", "No summary available.")
 
+        # Extract outcome measures
+        primary_outcome_str = self._extract_primary_outcome(outcomes_module)
+        secondary_count = len(outcomes_module.get("secondaryOutcomes", []))
+
+        # Check if results are available (hasResults is TOP-LEVEL, not in protocol!)
+        has_results = study.get("hasResults", False)
+
+        # Results date is in statusModule (nested inside date struct)
+        results_date_struct = status_module.get("resultsFirstPostDateStruct", {})
+        results_date = results_date_struct.get("date", "")
+
         # 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}."
-        )
+        summary_text = summary[:400] + "..." if len(summary) > 400 else summary
+        content_parts = [
+            summary_text,
+            f"Trial Phase: {phase}.",
+            f"Status: {status}.",
+            f"Conditions: {conditions_str}.",
+            f"Interventions: {interventions_str}.",
+        ]
+
+        if primary_outcome_str:
+            content_parts.append(f"Primary Outcome: {primary_outcome_str}.")
+
+        if secondary_count > 0:
+            content_parts.append(f"Secondary Outcomes: {secondary_count} additional endpoints.")
+
+        if has_results:
+            results_info = "Results Available: Yes"
+            if results_date:
+                results_info += f" (posted {results_date})"
+            content_parts.append(results_info + ".")
+        else:
+            content_parts.append("Results Available: Not yet posted.")
+
+        content = " ".join(content_parts)
 
         return Evidence(
             content=content[:2000],
@@ -139,5 +185,5 @@ class ClinicalTrialsTool:
                 date=start_date,
                 authors=[],  # Trials don't have traditional authors
             ),
-            relevance=0.85,  # Trials are highly relevant for repurposing
+            relevance=0.90 if has_results else 0.85,  # Boost relevance for trials with results
         )

tests/unit/tools/test_clinicaltrials.py

@@ -128,6 +128,150 @@ class TestClinicalTrialsTool:
             assert results == []
 
 
+@pytest.mark.unit
+class TestClinicalTrialsOutcomes:
+    """Tests for outcome measure extraction."""
+
+    @pytest.fixture
+    def tool(self) -> ClinicalTrialsTool:
+        return ClinicalTrialsTool()
+
+    @pytest.mark.asyncio
+    async def test_extracts_primary_outcome(self, tool: ClinicalTrialsTool) -> None:
+        """Test that primary outcome is extracted from response."""
+        mock_study = {
+            "protocolSection": {
+                "identificationModule": {"nctId": "NCT12345678", "briefTitle": "Test"},
+                "statusModule": {"overallStatus": "COMPLETED", "startDateStruct": {"date": "2023"}},
+                "descriptionModule": {"briefSummary": "Summary"},
+                "designModule": {"phases": ["PHASE3"]},
+                "conditionsModule": {"conditions": ["ED"]},
+                "armsInterventionsModule": {"interventions": []},
+                "outcomesModule": {
+                    "primaryOutcomes": [
+                        {"measure": "Change in IIEF-EF score", "timeFrame": "Week 12"}
+                    ]
+                },
+            },
+            "hasResults": True,
+        }
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"studies": [mock_study]}
+        mock_response.raise_for_status = MagicMock()
+
+        with patch("requests.get", return_value=mock_response):
+            results = await tool.search("test", max_results=1)
+
+            assert len(results) == 1
+            assert "Primary Outcome" in results[0].content
+            assert "IIEF-EF" in results[0].content
+            assert "Week 12" in results[0].content
+
+    @pytest.mark.asyncio
+    async def test_includes_results_status(self, tool: ClinicalTrialsTool) -> None:
+        """Test that results availability is shown."""
+        mock_study = {
+            "protocolSection": {
+                "identificationModule": {"nctId": "NCT12345678", "briefTitle": "Test"},
+                "statusModule": {
+                    "overallStatus": "COMPLETED",
+                    "startDateStruct": {"date": "2023"},
+                    # Note: resultsFirstPostDateStruct, not resultsFirstSubmitDate
+                    "resultsFirstPostDateStruct": {"date": "2024-06-15"},
+                },
+                "descriptionModule": {"briefSummary": "Summary"},
+                "designModule": {"phases": ["PHASE3"]},
+                "conditionsModule": {"conditions": ["ED"]},
+                "armsInterventionsModule": {"interventions": []},
+                "outcomesModule": {},
+            },
+            "hasResults": True,  # Note: hasResults is TOP-LEVEL
+        }
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"studies": [mock_study]}
+        mock_response.raise_for_status = MagicMock()
+
+        with patch("requests.get", return_value=mock_response):
+            results = await tool.search("test", max_results=1)
+
+            assert "Results Available: Yes" in results[0].content
+            assert "2024-06-15" in results[0].content
+
+    @pytest.mark.asyncio
+    async def test_shows_no_results_when_missing(self, tool: ClinicalTrialsTool) -> None:
+        """Test that missing results are indicated."""
+        mock_study = {
+            "protocolSection": {
+                "identificationModule": {
+                    "nctId": "NCT99999999",
+                    "briefTitle": "Test Study",
+                },
+                "statusModule": {
+                    "overallStatus": "RECRUITING",
+                    "startDateStruct": {"date": "2024"},
+                },
+                "descriptionModule": {"briefSummary": "Summary"},
+                "designModule": {"phases": ["PHASE2"]},
+                "conditionsModule": {"conditions": ["ED"]},
+                "armsInterventionsModule": {"interventions": []},
+                "outcomesModule": {},
+            },
+            "hasResults": False,
+        }
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"studies": [mock_study]}
+        mock_response.raise_for_status = MagicMock()
+
+        with patch("requests.get", return_value=mock_response):
+            results = await tool.search("test", max_results=1)
+
+            assert "Results Available: Not yet posted" in results[0].content
+
+    @pytest.mark.asyncio
+    async def test_boosts_relevance_for_results(self, tool: ClinicalTrialsTool) -> None:
+        """Trials with results should have higher relevance score."""
+        with_results = {
+            "protocolSection": {
+                "identificationModule": {"nctId": "NCT11111111", "briefTitle": "With Results"},
+                "statusModule": {"overallStatus": "COMPLETED", "startDateStruct": {"date": "2023"}},
+                "descriptionModule": {"briefSummary": "Summary"},
+                "designModule": {"phases": []},
+                "conditionsModule": {"conditions": []},
+                "armsInterventionsModule": {"interventions": []},
+                "outcomesModule": {},
+            },
+            "hasResults": True,
+        }
+        without_results = {
+            "protocolSection": {
+                "identificationModule": {"nctId": "NCT22222222", "briefTitle": "No Results"},
+                "statusModule": {
+                    "overallStatus": "RECRUITING",
+                    "startDateStruct": {"date": "2024"},
+                },
+                "descriptionModule": {"briefSummary": "Summary"},
+                "designModule": {"phases": []},
+                "conditionsModule": {"conditions": []},
+                "armsInterventionsModule": {"interventions": []},
+                "outcomesModule": {},
+            },
+            "hasResults": False,
+        }
+
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"studies": [with_results, without_results]}
+        mock_response.raise_for_status = MagicMock()
+
+        with patch("requests.get", return_value=mock_response):
+            results = await tool.search("test", max_results=2)
+
+            assert results[0].relevance == 0.90  # With results
+            assert results[1].relevance == 0.85  # Without results
+
+
 @pytest.mark.integration
 class TestClinicalTrialsIntegration:
     """Integration tests with real API."""
@@ -150,3 +294,21 @@ class TestClinicalTrialsIntegration:
             or "phase" in all_content
         )
         assert has_intervention
+
+    @pytest.mark.asyncio
+    async def test_real_completed_trial_has_outcome(self) -> None:
+        """Real completed Phase 3 trials should have outcome measures."""
+        tool = ClinicalTrialsTool()
+
+        # Search for completed Phase 3 ED trials (likely to have outcomes)
+        results = await tool.search(
+            "sildenafil erectile dysfunction Phase 3 COMPLETED", max_results=3
+        )
+
+        # Skip if API returns no results (external dependency)
+        if not results:
+            pytest.skip("API returned no results for this query")
+
+        # At least one should have primary outcome
+        has_outcome = any("Primary Outcome" in r.content for r in results)
+        assert has_outcome, "No completed trials with outcome measures found"