fix: P0 dedup bug + HF judge infinite loop prevention

Bug 1 - Semantic Dedup Removing All Evidence:
- Was calling _deduplicate_and_rank(all_evidence) every iteration
- Old items already in vector store found THEMSELVES as duplicates
- Fix: Only dedup NEW evidence, not entire accumulated list

Bug 2 - HF Judge Infinite Loop:
- HF Inference failures returned "continue" with 0% confidence
- Loop never terminated when API kept failing
- Fix: Track consecutive failures, force "synthesize" after 3 failures

Both bugs caused Simple mode (free tier) to loop forever with no output.
Now: Evidence accumulates properly AND loop terminates gracefully.

docs/bugs/P0_ORCHESTRATOR_DEDUP_AND_JUDGE_BUGS.md

@@ -0,0 +1,143 @@
+# P0 Bug Report: Orchestrator Dedup + Judge Failures
+
+## Status
+- **Date:** 2025-11-29
+- **Priority:** P0 (Blocker - Simple mode broken on HF Spaces)
+- **Component:** `src/orchestrator.py`, `src/agent_factory/judges.py`
+
+---
+
+## Symptoms
+
+When running Simple mode (free tier) on HuggingFace Spaces:
+
+1. **Judge always returns 0% confidence** → loops forever with "continue"
+2. **Deduplication removes ALL evidence** after iteration 1
+3. **Never synthesizes** → user sees infinite loop
+
+### Example Output
+
+```
+📚 SEARCH_COMPLETE: Found 20 new sources (19 total)   ← Iteration 1 OK
+✅ JUDGE_COMPLETE: Assessment: continue (confidence: 0%)  ← FAIL: 0% = fallback
+
+📚 SEARCH_COMPLETE: Found 12 new sources (11 total)   ← Iteration 2 BROKEN
+...
+📚 SEARCH_COMPLETE: Found 31 new sources (0 total)    ← 0 TOTAL = all removed!
+✅ JUDGE_COMPLETE: Assessment: continue (confidence: 0%)  ← Still failing
+```
+
+---
+
+## Root Cause Analysis
+
+### Bug 1: Semantic Deduplication Removes Old Evidence
+
+**File:** `src/orchestrator.py:213-219`
+
+```python
+# URL dedup (correct)
+seen_urls = {e.citation.url for e in all_evidence}
+unique_new = [e for e in new_evidence if e.citation.url not in seen_urls]
+all_evidence.extend(unique_new)
+
+# BUG: Passes ALL evidence (including old) to semantic dedup
+all_evidence = await self._deduplicate_and_rank(all_evidence, query)
+```
+
+**Problem:** The `deduplicate()` function checks each item against the vector store. Items from iteration 1 are ALREADY in the store. When re-checked in iteration 2+, they find THEMSELVES (distance ≈ 0) and are removed as "duplicates".
+
+**Result:** After iteration 1, evidence count drops to 0.
+
+### Bug 2: HF Inference Judge Always Failing
+
+**File:** `src/agent_factory/judges.py:186-254`
+
+**Evidence:** Judge returns this every time:
+- `confidence: 0.0`
+- `recommendation: "continue"`
+- Next queries are just the original query with suffixes
+
+This is the `_create_fallback_assessment()` response, meaning:
+- The HF Inference API calls are failing
+- All 3 fallback models (Llama, Mistral, Zephyr) are failing
+- Likely due to rate limits, quota, or model availability
+
+---
+
+## The Fix
+
+### Fix 1: Only Dedup NEW Evidence (not all_evidence)
+
+```python
+# Before (broken)
+all_evidence.extend(unique_new)
+all_evidence = await self._deduplicate_and_rank(all_evidence, query)
+
+# After (fixed)
+# Only dedup the NEW evidence against the store
+if unique_new:
+    unique_new = await self._deduplicate_new_evidence(unique_new, query)
+all_evidence.extend(unique_new)
+```
+
+Or simpler - disable semantic dedup until we fix it properly:
+
+```python
+# Disable broken semantic dedup
+# all_evidence = await self._deduplicate_and_rank(all_evidence, query)
+```
+
+### Fix 2: Handle HF Inference Failures Gracefully
+
+Option A: After N failed judge calls, force synthesize with available evidence
+Option B: Increase retry count or add longer backoff
+Option C: Fall back to MockJudgeHandler (which DOES work) after failures
+
+```python
+# In _create_fallback_assessment, track failures
+if self._consecutive_failures >= 3:
+    # Force synthesis instead of infinite loop
+    return JudgeAssessment(
+        sufficient=True,  # STOP
+        confidence=0.1,
+        recommendation="synthesize",
+        ...
+    )
+```
+
+---
+
+## Test Plan
+
+- [ ] Disable semantic dedup OR fix to only process new items
+- [ ] Verify evidence accumulates across iterations (not drops to 0)
+- [ ] Test HF Inference with fresh HF_TOKEN
+- [ ] If HF keeps failing, fall back to MockJudgeHandler
+- [ ] Verify "synthesize" is eventually reached
+- [ ] Deploy and test on HF Space
+
+---
+
+## Priority Justification
+
+**P0** because:
+- Simple mode (free tier) is the DEFAULT experience
+- Currently produces infinite loop with no output
+- Users see "confidence: 0%" and think tool is broken
+- Blocks hackathon demo for users without API keys
+
+---
+
+## Quick Workaround
+
+Disable semantic dedup by setting `enable_embeddings=False` in orchestrator creation:
+
+```python
+orchestrator = create_orchestrator(
+    ...
+    enable_embeddings=False,  # Disable broken dedup
+)
+```
+
+Or users can enter an OpenAI/Anthropic API key to bypass HF Inference issues.

src/agent_factory/judges.py

@@ -195,6 +195,8 @@ class HFInferenceJudgeHandler:
         "HuggingFaceH4/zephyr-7b-beta",  # Fallback (Ungated)
     ]
 
+    MAX_CONSECUTIVE_FAILURES: ClassVar[int] = 3  # Force synthesis after N failures
+
     def __init__(self, model_id: str | None = None) -> None:
         """
         Initialize with HF Inference client.
@@ -206,6 +208,7 @@ class HFInferenceJudgeHandler:
         # Will automatically use HF_TOKEN from env if available
         self.client = InferenceClient()
         self.call_count = 0
+        self.consecutive_failures = 0  # Track failures to prevent infinite loops
         self.last_question: str | None = None
         self.last_evidence: list[Evidence] | None = None
 
@@ -217,11 +220,22 @@ class HFInferenceJudgeHandler:
         """
         Assess evidence using HuggingFace Inference API.
         Attempts models in order until one succeeds.
+
+        After MAX_CONSECUTIVE_FAILURES, forces synthesis to prevent infinite loops.
         """
         self.call_count += 1
         self.last_question = question
         self.last_evidence = evidence
 
+        # BUG FIX: After N consecutive failures, force synthesis to break infinite loop
+        if self.consecutive_failures >= self.MAX_CONSECUTIVE_FAILURES:
+            logger.warning(
+                "Max consecutive failures reached, forcing synthesis",
+                failures=self.consecutive_failures,
+                evidence_count=len(evidence),
+            )
+            return self._create_forced_synthesis_assessment(question, evidence)
+
         # Format the user prompt
         if evidence:
             user_prompt = format_user_prompt(question, evidence)
@@ -233,7 +247,9 @@ class HFInferenceJudgeHandler:
 
         for model in models_to_try:
             try:
-                return await self._call_with_retry(model, user_prompt, question)
+                result = await self._call_with_retry(model, user_prompt, question)
+                self.consecutive_failures = 0  # Reset on success
+                return result
             except Exception as e:
                 # Check for 402/Quota errors to fail fast
                 error_str = str(e)
@@ -249,8 +265,13 @@ class HFInferenceJudgeHandler:
                 last_error = e
                 continue
 
-        # All models failed
-        logger.error("All HF models failed", error=str(last_error))
+        # All models failed - increment failure counter
+        self.consecutive_failures += 1
+        logger.error(
+            "All HF models failed",
+            error=str(last_error),
+            consecutive_failures=self.consecutive_failures,
+        )
         return self._create_fallback_assessment(question, str(last_error))
 
     @retry(
@@ -402,6 +423,41 @@ IMPORTANT: Respond with ONLY valid JSON matching this schema:
             ),
         )
 
+    def _create_forced_synthesis_assessment(
+        self, question: str, evidence: list[Evidence]
+    ) -> JudgeAssessment:
+        """Force synthesis after repeated failures to prevent infinite loops."""
+        findings = _extract_titles_from_evidence(
+            evidence,
+            max_items=5,
+            fallback_message="No findings available (API failures prevented analysis).",
+        )
+
+        return JudgeAssessment(
+            details=AssessmentDetails(
+                mechanism_score=0,
+                mechanism_reasoning="AI analysis unavailable after repeated API failures.",
+                clinical_evidence_score=0,
+                clinical_reasoning="AI analysis unavailable after repeated API failures.",
+                drug_candidates=["AI analysis required for drug identification."],
+                key_findings=findings,
+            ),
+            sufficient=True,  # FORCE STOP
+            confidence=0.1,
+            recommendation="synthesize",
+            next_search_queries=[],
+            reasoning=(
+                f"⚠️ **HF Inference Unavailable** ⚠️\n\n"
+                f"The free tier AI service failed {self.MAX_CONSECUTIVE_FAILURES} times. "
+                f"Search found {len(evidence)} sources (listed below) but they could not "
+                "be analyzed by AI.\n\n"
+                "**Options:**\n"
+                "- Add an OpenAI or Anthropic API key for reliable analysis\n"
+                "- Try again later when HF Inference is available\n"
+                "- Review the raw search results below"
+            ),
+        )
+
     def _create_fallback_assessment(
         self,
         question: str,

src/orchestrator.py

@@ -213,10 +213,14 @@ class Orchestrator:
                 # Deduplicate evidence by URL (fast, basic)
                 seen_urls = {e.citation.url for e in all_evidence}
                 unique_new = [e for e in new_evidence if e.citation.url not in seen_urls]
-                all_evidence.extend(unique_new)
 
-                # Semantic deduplication and ranking (if embeddings available)
-                all_evidence = await self._deduplicate_and_rank(all_evidence, query)
+                # BUG FIX: Only dedup NEW evidence, not all_evidence
+                # Old evidence is already in the vector store - re-checking it
+                # would mark items as duplicates of themselves (distance ≈ 0)
+                if unique_new:
+                    unique_new = await self._deduplicate_and_rank(unique_new, query)
+
+                all_evidence.extend(unique_new)
 
                 yield AgentEvent(
                     type="search_complete",