fix: Remove fallback_to_heuristics and all heuristic methods from AmbiguityResolver

- Removed fallback_to_heuristics parameter from __init__
- Removed all heuristic resolution methods (_resolve_*_heuristic)
- Removed _resolve_with_heuristics method
- Removed _classify_ambiguity method
- Removed _fallback_resolution method
- Updated error message to require a real model
- AmbiguityResolver now always requires a real AI model

This ensures tests fail properly when no real model is available, following
the NO MOCKS policy. The GitHub Actions test expecting a fallback will now
correctly fail and need to be fixed to provide a real model.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: jeremymanning

src/orchestrator/compiler/ambiguity_resolver.py

@@ -38,35 +38,22 @@ class AmbiguityResolver:
     def __init__(
         self, 
         model: Optional[Model] = None,
-        model_registry: Optional[ModelRegistry] = None,
-        fallback_to_heuristics: bool = False
+        model_registry: Optional[ModelRegistry] = None
     ) -> None:
         """
         Initialize ambiguity resolver.
 
         Args:
             model: Specific model to use for resolution
             model_registry: Model registry to select models from
-            fallback_to_heuristics: Whether to fall back to heuristics if AI fails
             
         Raises:
             ValueError: If no model is provided and registry has no models
         """
         self.model = model
         self.model_registry = model_registry
-        self.fallback_to_heuristics = fallback_to_heuristics
         self.resolution_cache: Dict[str, Any] = {}
 
-        # Heuristic strategies for fallback
-        self.resolution_strategies = {
-            "parameter": self._resolve_parameter_heuristic,
-            "value": self._resolve_value_heuristic,
-            "list": self._resolve_list_heuristic,
-            "boolean": self._resolve_boolean_heuristic,
-            "number": self._resolve_number_heuristic,
-            "string": self._resolve_string_heuristic,
-        }
-        
         # If no model provided, try to get one from registry
         if not model and model_registry:
             available_models = model_registry.list_models()
@@ -79,10 +66,10 @@ def __init__(
                     self.model = model_registry.get_model(available_models[0])
 
         # Verify we have a model for AI resolution
-        if not self.model and not self.fallback_to_heuristics:
+        if not self.model:
             raise ValueError(
                 "No AI model available for ambiguity resolution. "
-                "Either provide a model or enable fallback_to_heuristics."
+                "A real model must be provided."
             )
 
     async def resolve(self, content: str, context_path: str) -> Any:
@@ -105,31 +92,19 @@ async def resolve(self, content: str, context_path: str) -> Any:
             return self.resolution_cache[cache_key]
 
         try:
-            # Try AI resolution first if we have a model
+            # Try AI resolution with the model
             if self.model:
                 result = await self._resolve_with_ai(content, context_path)
-            elif self.fallback_to_heuristics:
-                # Fall back to heuristic resolution
-                result = await self._resolve_with_heuristics(content, context_path)
             else:
                 raise AmbiguityResolutionError(
-                    "No AI model available and heuristic fallback is disabled"
+                    "No AI model available for ambiguity resolution"
                 )
 
             # Cache result
             self.resolution_cache[cache_key] = result
             return result
 
         except Exception as e:
-            if self.fallback_to_heuristics and self.model:
-                # If AI failed, try heuristics
-                try:
-                    result = await self._resolve_with_heuristics(content, context_path)
-                    self.resolution_cache[cache_key] = result
-                    return result
-                except:
-                    pass
-            
             raise AmbiguityResolutionError(
                 f"Failed to resolve ambiguity '{content}' at {context_path}: {e}"
             ) from e
@@ -252,188 +227,6 @@ def _parse_ai_response(self, response: str, expected_type: str, original_content
             # String - clean up the response
             return response.strip('"\'')
 
-    async def _resolve_with_heuristics(self, content: str, context_path: str) -> Any:
-        """Fall back to heuristic resolution."""
-        # Classify ambiguity type
-        resolution_type = self._classify_ambiguity(content, context_path)
-        
-        # Apply resolution strategy
-        if resolution_type in self.resolution_strategies:
-            strategy = self.resolution_strategies[resolution_type]
-            return await strategy(content, context_path)
-        else:
-            # Default to string
-            return content
-
-    def _classify_ambiguity(self, content: str, context_path: str) -> str:
-        """Classify the type of ambiguity for heuristic resolution."""
-        content_lower = content.lower()
-
-        # Check for explicit choice patterns
-        if ("choose" in content_lower or "select" in content_lower):
-            if any(word in content_lower for word in ["true", "false"]):
-                return "boolean"
-            elif any(word in content_lower for word in ["number", "size", "count", "amount"]):
-                return "number"
-            elif "list" in content_lower or "array" in content_lower:
-                return "list"
-            else:
-                return "value"
-
-        # Check for parameter context
-        if "parameters" in context_path:
-            return "parameter"
-
-        # Check for specific patterns
-        if re.search(r'"[^"]*"', content):
-            return "string"
-        
-        # Context-based classification
-        path_parts = context_path.lower().split('.')
-        if any(part in ["format", "type", "style", "method"] for part in path_parts):
-            return "string"
-        elif any(part in ["enable", "disable", "support"] for part in path_parts):
-            return "boolean"
-        elif any(part in ["count", "size", "limit", "timeout", "batch"] for part in path_parts):
-            return "number"
-        elif any(part in ["languages", "formats", "items", "sources", "tags", "options", "list"] for part in path_parts):
-            return "list"
-        
-        return "string"
-
-    # Heuristic resolution methods
-    async def _resolve_parameter_heuristic(self, content: str, context_path: str) -> Any:
-        """Heuristic parameter resolution."""
-        # Check context for common patterns
-        if "format" in context_path:
-            return "json"
-        elif "method" in context_path:
-            return "default"
-        elif "type" in context_path:
-            return "auto"
-        return "default"
-
-    async def _resolve_value_heuristic(self, content: str, context_path: str) -> Any:
-        """Heuristic value resolution."""
-        # Extract choices if present
-        choices = self._extract_choices(content)
-        if choices:
-            return choices[0]
-        
-        # Check for specific patterns
-        if "format" in context_path:
-            return "json"
-        elif "method" in context_path:
-            return "auto"
-        elif "style" in context_path:
-            return "default"
-        
-        return "default"
-
-    async def _resolve_list_heuristic(self, content: str, context_path: str) -> List[str]:
-        """Heuristic list resolution."""
-        # Context-based defaults
-        if "source" in context_path:
-            return ["web", "documents", "database"]
-        elif "format" in context_path:
-            return ["json", "csv", "xml"]
-        elif "language" in context_path:
-            return ["en", "es", "fr"]
-        return ["item1", "item2", "item3"]
-
-    async def _resolve_boolean_heuristic(self, content: str, context_path: str) -> bool:
-        """Heuristic boolean resolution."""
-        content_lower = content.lower()
-        
-        # Check for explicit indicators
-        positive = ["enable", "true", "yes", "allow", "support"]
-        negative = ["disable", "false", "no", "deny", "block"]
-        
-        for word in positive:
-            if word in content_lower:
-                return True
-        
-        for word in negative:
-            if word in content_lower:
-                return False
-        
-        # Context-based defaults
-        if "enable" in context_path or "support" in context_path:
-            return True
-        
-        return False
-
-    async def _resolve_number_heuristic(self, content: str, context_path: str) -> Union[int, float]:
-        """Heuristic number resolution."""
-        # Context-based defaults
-        if "batch" in context_path:
-            return 32
-        elif "timeout" in context_path:
-            return 30
-        elif "retry" in context_path:
-            return 3
-        elif "size" in context_path:
-            return 100
-        elif "limit" in context_path:
-            return 1000
-        return 10
-
-    async def _resolve_string_heuristic(self, content: str, context_path: str) -> str:
-        """Heuristic string resolution."""
-        # Extract quoted content
-        quotes = self._extract_quotes(content)
-        if quotes:
-            return quotes[0]
-        
-        # Context-based defaults
-        if "query" in context_path:
-            return "default search query"
-        elif "format" in context_path:
-            return "json"
-        elif "method" in context_path:
-            return "auto"
-        elif "style" in context_path:
-            return "default"
-        elif "type" in context_path:
-            return "standard"
-        
-        return "default"
-
-    def _extract_choices(self, content: str) -> List[str]:
-        """Extract choices from content."""
-        # Pattern for "Choose: A, B, C" or "Select from: A, B, C"
-        pattern = r'(?:choose|select)(?:\s+from)?:\s*([^.]+)'
-        match = re.search(pattern, content, re.IGNORECASE)
-        
-        if match:
-            choices_text = match.group(1)
-            # Split by comma and clean
-            choices = [c.strip() for c in choices_text.split(',')]
-            # Remove 'or' from choices
-            choices = [c.replace(' or ', '').replace('or ', '').strip() for c in choices]
-            return [c for c in choices if c]
-        
-        return []
-
-    def _extract_quotes(self, content: str) -> List[str]:
-        """Extract quoted strings from content."""
-        pattern = r'"([^"]*)"'
-        return re.findall(pattern, content)
-
-    def _fallback_resolution(self, content: str, context_path: str) -> Any:
-        """Ultimate fallback resolution."""
-        # This is used by tests that expect specific behavior
-        if "query" in context_path:
-            return "default search query"
-        elif "format" in context_path:
-            return "json"
-        elif "method" in context_path:
-            return "auto"
-        elif "style" in context_path:
-            return "default"
-        elif "type" in context_path:
-            return "standard"
-        return "default"
 
     def clear_cache(self) -> None:
         """Clear the resolution cache."""