Delete infrastructure

infrastructure/__init__.py

@@ -1,23 +0,0 @@
-from .intents import (
-    ResourceType, PermissionLevel, Environment, ChangeScope,
-    ProvisionResourceIntent, DeployConfigurationIntent, GrantAccessIntent,
-    InfrastructureIntent
-)
-from .policies import (
-    Policy, RegionAllowedPolicy, ResourceTypeRestrictedPolicy,
-    MaxPermissionLevelPolicy, CostThresholdPolicy, PolicyEvaluator,
-    allow_all, deny_all
-)
-from .cost_estimator import CostEstimator
-from .risk_engine import RiskEngine
-from .healing_intent import HealingIntent, RecommendedAction, IntentSource
-from .azure.azure_simulator import AzureInfrastructureSimulator
-
-__all__ = [
-    "ResourceType", "PermissionLevel", "Environment", "ChangeScope",
-    "ProvisionResourceIntent", "DeployConfigurationIntent", "GrantAccessIntent",
-    "InfrastructureIntent", "Policy", "RegionAllowedPolicy",
-    "ResourceTypeRestrictedPolicy", "MaxPermissionLevelPolicy", "CostThresholdPolicy",
-    "PolicyEvaluator", "allow_all", "deny_all", "CostEstimator", "RiskEngine",
-    "HealingIntent", "RecommendedAction", "IntentSource", "AzureInfrastructureSimulator"
-]

infrastructure/azure/__init__.py

@@ -1,4 +0,0 @@
-from .azure_simulator import AzureInfrastructureSimulator
-from .azure_models import AzureResource, AzureDeployment
-
-__all__ = ["AzureInfrastructureSimulator", "AzureResource", "AzureDeployment"]

infrastructure/azure/azure_models.py

@@ -1,17 +0,0 @@
-"""
-Azure-specific models (minimal for simulation).
-"""
-from pydantic import BaseModel
-from typing import Optional, Dict, Any
-
-class AzureResource(BaseModel):
-    resource_id: str
-    resource_type: str
-    location: str
-    tags: Dict[str, str] = {}
-
-class AzureDeployment(BaseModel):
-    deployment_id: str
-    template: Dict[str, Any]
-    parameters: Dict[str, Any]
-    resource_group: str

infrastructure/azure/azure_simulator.py

@@ -1,89 +0,0 @@
-"""
-Azure Infrastructure Simulator – Main orchestration engine.
-"""
-
-from typing import List, Optional, Dict, Any
-
-from ..intents import (
-    InfrastructureIntent,
-    ProvisionResourceIntent,
-)
-from ..policies import (
-    Policy,
-    PolicyEvaluator,
-    CostThresholdPolicy,
-)
-from ..cost_estimator import CostEstimator
-from ..risk_engine import RiskEngine
-from ..healing_intent import (
-    HealingIntent,
-    RecommendedAction,
-    IntentSource,
-)
-from ..constants import MAX_POLICY_VIOLATIONS
-
-
-class AzureInfrastructureSimulator:
-    def __init__(
-        self,
-        policy: Policy,
-        pricing_file: Optional[str] = None,
-        risk_factors: Optional[List] = None,
-    ):
-        self._policy_evaluator = PolicyEvaluator(policy)
-        self._cost_estimator = CostEstimator(pricing_file)
-        self._risk_engine = RiskEngine(risk_factors if risk_factors else RiskEngine.DEFAULT_FACTORS)
-
-    def evaluate(self, intent: InfrastructureIntent) -> HealingIntent:
-        cost = None
-        if isinstance(intent, ProvisionResourceIntent):
-            cost = self._cost_estimator.estimate_monthly_cost(intent)
-
-        context = {"cost_estimate": cost} if cost is not None else {}
-        violations = self._policy_evaluator.evaluate(intent, context)
-
-        if len(violations) > MAX_POLICY_VIOLATIONS:
-            violations = violations[:MAX_POLICY_VIOLATIONS]
-
-        risk_score, explanation, contributions = self._risk_engine.calculate_risk(
-            intent, cost, violations
-        )
-
-        if risk_score > 0.8 or violations:
-            recommended_action = RecommendedAction.DENY
-        elif risk_score > 0.4:
-            recommended_action = RecommendedAction.ESCALATE
-        else:
-            recommended_action = RecommendedAction.APPROVE
-
-        justification_parts = [f"Risk score: {risk_score:.2f}."]
-        if cost is not None:
-            justification_parts.append(f"Estimated monthly cost: ${cost:.2f}.")
-        if violations:
-            justification_parts.append(f"Policy violations: {'; '.join(violations)}.")
-        justification_parts.append(explanation)
-        justification = " ".join(justification_parts)
-
-        intent_summary = f"{intent.intent_type} requested by {intent.requester}"
-
-        details = {
-            "cost_estimate": cost,
-            "violations": violations,
-            "risk_score": risk_score,
-            "factor_contributions": contributions,
-        }
-
-        healing_intent = HealingIntent(
-            intent_id=intent.intent_id,
-            intent_summary=intent_summary,
-            cost_projection=cost,
-            risk_score=risk_score,
-            policy_violations=violations,
-            recommended_action=recommended_action,
-            justification=justification,
-            confidence_score=0.9,
-            evaluation_details=details,
-            source=IntentSource.INFRASTRUCTURE_ANALYSIS,
-        )
-
-        return healing_intent.mark_as_oss_advisory()

infrastructure/constants.py

@@ -1,21 +0,0 @@
-"""
-ARF OSS constants – shared across modules.
-"""
-
-OSS_EDITION = "OSS"
-OSS_LICENSE = "Apache 2.0"
-ENTERPRISE_UPGRADE_URL = "https://huggingface.co/spaces/petter2025/agentic-reliability-framework?enterprise"
-EXECUTION_ALLOWED = False
-
-# Limits
-MAX_SIMILARITY_CACHE = 100
-SIMILARITY_THRESHOLD = 0.7
-MAX_POLICY_VIOLATIONS = 10
-MAX_RISK_FACTORS = 20
-MAX_COST_PROJECTIONS = 5
-MAX_DECISION_TREE_DEPTH = 5
-MAX_ALTERNATIVE_ACTIONS = 5
-
-class OSSBoundaryError(Exception):
-    """Raised when OSS edition attempts an enterprise-only operation."""
-    pass

infrastructure/cost_estimator.py

@@ -1,102 +0,0 @@
-"""
-Cost Estimation Engine – Deterministic pricing with Bayesian uncertainty.
-"""
-
-import os
-from functools import lru_cache
-from typing import Dict, Optional, Union, Any
-import yaml
-
-from .intents import ProvisionResourceIntent, ResourceType
-
-class CostEstimator:
-    DEFAULT_PRICING = {
-        ResourceType.VM: {
-            "Standard_D2s_v3": 70.0,
-            "Standard_D4s_v3": 140.0,
-            "Standard_D8s_v3": 280.0,
-            "Standard_D16s_v3": 560.0,
-        },
-        ResourceType.STORAGE_ACCOUNT: {
-            "50GB": 5.0,
-            "100GB": 10.0,
-            "1TB": 100.0,
-            "10TB": 900.0,
-        },
-        ResourceType.DATABASE: {
-            "Basic": 15.0,
-            "Standard": 50.0,
-            "Premium": 200.0,
-        },
-        ResourceType.KUBERNETES_CLUSTER: {
-            "Small": 100.0,
-            "Medium": 300.0,
-            "Large": 600.0,
-        },
-        ResourceType.FUNCTION_APP: {
-            "Consumption": 0.0,
-            "Premium": 75.0,
-        },
-        ResourceType.VIRTUAL_NETWORK: {
-            "default": 0.0,
-        },
-    }
-
-    def __init__(self, pricing_file: Optional[str] = None):
-        if pricing_file and os.path.exists(pricing_file):
-            with open(pricing_file, 'r') as f:
-                raw = yaml.safe_load(f)
-            self._pricing = {}
-            for res_str, sizes in raw.items():
-                try:
-                    res_type = ResourceType(res_str)
-                except ValueError:
-                    continue
-                self._pricing[res_type] = sizes
-        else:
-            self._pricing = self.DEFAULT_PRICING.copy()
-
-        # Cache for estimate_monthly_cost using a hashable key
-        self._cost_cache = {}
-
-    def estimate_monthly_cost(self, intent: ProvisionResourceIntent) -> Optional[float]:
-        # Create a hashable key from the intent's immutable fields
-        # (resource_type, size, region, environment) – configuration is omitted as it doesn't affect cost in this demo.
-        key = (intent.resource_type, intent.size, intent.region, intent.environment)
-        if key in self._cost_cache:
-            return self._cost_cache[key]
-
-        resource_pricing = self._pricing.get(intent.resource_type)
-        if not resource_pricing:
-            self._cost_cache[key] = None
-            return None
-        cost = resource_pricing.get(intent.size)
-        self._cost_cache[key] = cost
-        return cost
-
-    def cost_delta_vs_baseline(
-        self,
-        intent: ProvisionResourceIntent,
-        baseline_intent: Optional[ProvisionResourceIntent] = None,
-    ) -> Optional[float]:
-        proposed = self.estimate_monthly_cost(intent)
-        if proposed is None:
-            return None
-
-        if baseline_intent:
-            baseline = self.estimate_monthly_cost(baseline_intent)
-            if baseline is None:
-                return None
-            return proposed - baseline
-        else:
-            resource_pricing = self._pricing.get(intent.resource_type)
-            if not resource_pricing:
-                return None
-            min_cost = min(resource_pricing.values())
-            return proposed - min_cost
-
-    def estimate_cost_distribution(self, intent: ProvisionResourceIntent) -> Dict[str, float]:
-        cost = self.estimate_monthly_cost(intent)
-        if cost is None:
-            return {}
-        return {str(cost): 1.0}

infrastructure/healing_intent.py

@@ -1,848 +0,0 @@
-"""
-Healing Intent - OSS creates, Enterprise executes
-"""
-
-from dataclasses import dataclass, field, asdict
-from typing import Dict, Any, Optional, List, ClassVar, Tuple, Union
-from datetime import datetime
-import hashlib
-import json
-import time
-import uuid
-from enum import Enum
-import numpy as np
-
-from .intents import InfrastructureIntent
-from .constants import (
-    OSS_EDITION,
-    OSS_LICENSE,
-    ENTERPRISE_UPGRADE_URL,
-    EXECUTION_ALLOWED,
-    MAX_SIMILARITY_CACHE,
-    SIMILARITY_THRESHOLD,
-    MAX_POLICY_VIOLATIONS,
-    MAX_RISK_FACTORS,
-    MAX_COST_PROJECTIONS,
-    MAX_DECISION_TREE_DEPTH,
-    MAX_ALTERNATIVE_ACTIONS,
-    OSSBoundaryError,
-)
-
-class HealingIntentError(Exception): pass
-class SerializationError(HealingIntentError): pass
-class ValidationError(HealingIntentError): pass
-
-class IntentSource(str, Enum):
-    OSS_ANALYSIS = "oss_analysis"
-    HUMAN_OVERRIDE = "human_override"
-    AUTOMATED_LEARNING = "automated_learning"
-    SCHEDULED_ACTION = "scheduled_action"
-    RAG_SIMILARITY = "rag_similarity"
-    INFRASTRUCTURE_ANALYSIS = "infrastructure_analysis"
-    POLICY_VIOLATION = "policy_violation"
-    COST_OPTIMIZATION = "cost_optimization"
-
-class IntentStatus(str, Enum):
-    CREATED = "created"
-    PENDING_EXECUTION = "pending_execution"
-    EXECUTING = "executing"
-    EXECUTING_PARTIAL = "executing_partial"
-    COMPLETED = "completed"
-    COMPLETED_PARTIAL = "completed_partial"
-    FAILED = "failed"
-    REJECTED = "rejected"
-    CANCELLED = "cancelled"
-    ROLLED_BACK = "rolled_back"
-    OSS_ADVISORY_ONLY = "oss_advisory_only"
-    PENDING_APPROVAL = "pending_approval"
-    APPROVED = "approved"
-    APPROVED_WITH_OVERRIDES = "approved_with_overrides"
-
-class RecommendedAction(str, Enum):
-    APPROVE = "approve"
-    DENY = "deny"
-    ESCALATE = "escalate"
-    DEFER = "defer"
-
-class ConfidenceDistribution:
-    def __init__(self, mean: float, std: float = 0.05, samples: Optional[List[float]] = None):
-        self.mean = max(0.0, min(mean, 1.0))
-        self.std = max(0.0, min(std, 0.5))
-        self._samples = samples or list(np.random.normal(self.mean, self.std, 1000).clip(0, 1))
-
-    @property
-    def p5(self) -> float:
-        return float(np.percentile(self._samples, 5))
-
-    @property
-    def p50(self) -> float:
-        return float(np.percentile(self._samples, 50))
-
-    @property
-    def p95(self) -> float:
-        return float(np.percentile(self._samples, 95))
-
-    @property
-    def confidence_interval(self) -> Tuple[float, float]:
-        return (self.p5, self.p95)
-
-    def to_dict(self) -> Dict[str, float]:
-        return {
-            "mean": self.mean,
-            "std": self.std,
-            "p5": self.p5,
-            "p50": self.p50,
-            "p95": self.p95
-        }
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, float]) -> "ConfidenceDistribution":
-        return cls(mean=data["mean"], std=data.get("std", 0.05), samples=None)
-
-    def __repr__(self) -> str:
-        return f"ConfidenceDistribution(mean={self.mean:.3f}, 95% CI=[{self.p5:.3f}, {self.p95:.3f}])"
-
-@dataclass(frozen=True, slots=True)
-class HealingIntent:
-    action: str
-    component: str
-    parameters: Dict[str, Any] = field(default_factory=dict)
-    justification: str = ""
-    confidence: float = 0.85
-    confidence_distribution: Optional[Dict[str, float]] = None
-    incident_id: str = ""
-    detected_at: float = field(default_factory=time.time)
-    risk_score: Optional[float] = None
-    risk_factors: Optional[Dict[str, float]] = None
-    cost_projection: Optional[float] = None
-    cost_confidence_interval: Optional[Tuple[float, float]] = None
-    recommended_action: Optional[RecommendedAction] = None
-    decision_tree: Optional[List[Dict[str, Any]]] = None
-    alternative_actions: Optional[List[Dict[str, Any]]] = None
-    risk_profile: Optional[str] = None
-    reasoning_chain: Optional[List[Dict[str, Any]]] = None
-    similar_incidents: Optional[List[Dict[str, Any]]] = None
-    rag_similarity_score: Optional[float] = None
-    source: IntentSource = IntentSource.OSS_ANALYSIS
-    intent_id: str = field(default_factory=lambda: f"intent_{uuid.uuid4().hex[:16]}")
-    created_at: float = field(default_factory=time.time)
-    status: IntentStatus = IntentStatus.CREATED
-    execution_id: Optional[str] = None
-    executed_at: Optional[float] = None
-    execution_result: Optional[Dict[str, Any]] = None
-    enterprise_metadata: Dict[str, Any] = field(default_factory=dict)
-    human_overrides: List[Dict[str, Any]] = field(default_factory=list)
-    approvals: List[Dict[str, Any]] = field(default_factory=list)
-    comments: List[Dict[str, Any]] = field(default_factory=list)
-    oss_edition: str = OSS_EDITION
-    oss_license: str = OSS_LICENSE
-    requires_enterprise: bool = True
-    execution_allowed: bool = EXECUTION_ALLOWED
-    infrastructure_intent_id: Optional[str] = None
-    policy_violations: List[str] = field(default_factory=list)
-    infrastructure_intent: Optional[Dict[str, Any]] = None
-
-    MIN_CONFIDENCE: ClassVar[float] = 0.0
-    MAX_CONFIDENCE: ClassVar[float] = 1.0
-    MAX_JUSTIFICATION_LENGTH: ClassVar[int] = 5000
-    MAX_PARAMETERS_SIZE: ClassVar[int] = 100
-    MAX_SIMILAR_INCIDENTS: ClassVar[int] = MAX_SIMILARITY_CACHE
-    VERSION: ClassVar[str] = "2.0.0"
-
-    def __post_init__(self) -> None:
-        self._validate_oss_boundaries()
-        self._validate_risk_integration()
-
-    def _validate_oss_boundaries(self) -> None:
-        errors: List[str] = []
-        if not (self.MIN_CONFIDENCE <= self.confidence <= self.MAX_CONFIDENCE):
-            errors.append(f"Confidence must be between {self.MIN_CONFIDENCE} and {self.MAX_CONFIDENCE}, got {self.confidence}")
-        if len(self.justification) > self.MAX_JUSTIFICATION_LENGTH:
-            errors.append(f"Justification exceeds max length {self.MAX_JUSTIFICATION_LENGTH}")
-        if not self.action or not self.action.strip():
-            errors.append("Action cannot be empty")
-        if not self.component or not self.component.strip():
-            errors.append("Component cannot be empty")
-        if len(self.parameters) > self.MAX_PARAMETERS_SIZE:
-            errors.append(f"Too many parameters: {len(self.parameters)} > {self.MAX_PARAMETERS_SIZE}")
-        try:
-            json.dumps(self.parameters)
-        except (TypeError, ValueError) as e:
-            errors.append(f"Parameters must be JSON serializable: {e}")
-        if self.similar_incidents and len(self.similar_incidents) > self.MAX_SIMILAR_INCIDENTS:
-            errors.append(f"Too many similar incidents: {len(self.similar_incidents)} > {self.MAX_SIMILAR_INCIDENTS}")
-        if self.oss_edition == OSS_EDITION:
-            if self.execution_allowed:
-                errors.append("Execution not allowed in OSS edition")
-            if self.status == IntentStatus.EXECUTING:
-                errors.append("EXECUTING status not allowed in OSS edition")
-            if self.executed_at is not None:
-                errors.append("executed_at should not be set in OSS edition")
-            if self.execution_id is not None:
-                errors.append("execution_id should not be set in OSS edition")
-        if errors:
-            raise ValidationError("HealingIntent validation failed:\n" + "\n".join(f"  • {error}" for error in errors))
-
-    def _validate_risk_integration(self) -> None:
-        if self.risk_score is not None and not (0.0 <= self.risk_score <= 1.0):
-            raise ValidationError(f"Risk score must be between 0 and 1, got {self.risk_score}")
-        if self.cost_projection is not None and self.cost_projection < 0:
-            raise ValidationError(f"Cost projection cannot be negative, got {self.cost_projection}")
-        if self.cost_confidence_interval is not None:
-            low, high = self.cost_confidence_interval
-            if low > high:
-                raise ValidationError(f"Invalid confidence interval: [{low}, {high}]")
-
-    @property
-    def deterministic_id(self) -> str:
-        data = {
-            "action": self.action,
-            "component": self.component,
-            "parameters": self._normalize_parameters(self.parameters),
-            "incident_id": self.incident_id,
-            "detected_at": int(self.detected_at),
-            "oss_edition": self.oss_edition,
-        }
-        json_str = json.dumps(data, sort_keys=True, default=str)
-        hash_digest = hashlib.sha256(json_str.encode()).hexdigest()
-        return f"intent_{hash_digest[:16]}"
-
-    @property
-    def age_seconds(self) -> float:
-        return time.time() - self.created_at
-
-    @property
-    def is_executable(self) -> bool:
-        if self.oss_edition == OSS_EDITION:
-            return False
-        return self.status in [IntentStatus.CREATED, IntentStatus.PENDING_EXECUTION, IntentStatus.APPROVED]
-
-    @property
-    def is_oss_advisory(self) -> bool:
-        return self.oss_edition == OSS_EDITION and not self.execution_allowed
-
-    @property
-    def requires_enterprise_upgrade(self) -> bool:
-        return self.requires_enterprise and self.oss_edition == OSS_EDITION
-
-    @property
-    def confidence_interval(self) -> Optional[Tuple[float, float]]:
-        if self.confidence_distribution:
-            return (self.confidence_distribution.get("p5", self.confidence), self.confidence_distribution.get("p95", self.confidence))
-        return None
-
-    def to_enterprise_request(self) -> Dict[str, Any]:
-        return {
-            "intent_id": self.deterministic_id,
-            "action": self.action,
-            "component": self.component,
-            "parameters": self.parameters,
-            "justification": self.justification,
-            "confidence": self.confidence,
-            "confidence_interval": self.confidence_interval,
-            "risk_score": self.risk_score,
-            "cost_projection": self.cost_projection,
-            "incident_id": self.incident_id,
-            "detected_at": self.detected_at,
-            "created_at": self.created_at,
-            "source": self.source.value,
-            "recommended_action": self.recommended_action.value if self.recommended_action else None,
-            "oss_edition": self.oss_edition,
-            "oss_license": self.oss_license,
-            "requires_enterprise": self.requires_enterprise,
-            "execution_allowed": self.execution_allowed,
-            "version": self.VERSION,
-            "oss_metadata": {
-                "similar_incidents_count": len(self.similar_incidents) if self.similar_incidents else 0,
-                "rag_similarity_score": self.rag_similarity_score,
-                "has_reasoning_chain": self.reasoning_chain is not None,
-                "source": self.source.value,
-                "is_oss_advisory": self.is_oss_advisory,
-                "risk_factors": self.risk_factors,
-                "policy_violations_count": len(self.policy_violations) if self.policy_violations else 0,
-                "confidence_basis": self._get_confidence_basis(),
-                "learning_applied": False,
-                "learning_reason": "OSS advisory mode does not persist or learn from outcomes",
-            },
-            "upgrade_url": ENTERPRISE_UPGRADE_URL,
-            "enterprise_features": [
-                "autonomous_execution",
-                "approval_workflows",
-                "persistent_storage",
-                "learning_engine",
-                "audit_trails",
-                "compliance_reports",
-                "multi_tenant_support",
-                "sso_integration",
-                "24_7_support",
-                "probabilistic_confidence",
-                "risk_analytics",
-                "cost_optimization"
-            ]
-        }
-
-    def _get_confidence_basis(self) -> str:
-        if self.recommended_action == RecommendedAction.DENY and self.policy_violations:
-            return "policy_violation"
-        if self.rag_similarity_score and self.rag_similarity_score > SIMILARITY_THRESHOLD:
-            return "historical_similarity"
-        if self.risk_score is not None:
-            return "risk_based"
-        return "policy_only"
-
-    def to_dict(self, include_oss_context: bool = False) -> Dict[str, Any]:
-        data = asdict(self)
-        if "source" in data and isinstance(data["source"], IntentSource):
-            data["source"] = self.source.value
-        if "status" in data and isinstance(data["status"], IntentStatus):
-            data["status"] = self.status.value
-        if "recommended_action" in data and isinstance(data["recommended_action"], RecommendedAction):
-            data["recommended_action"] = self.recommended_action.value if self.recommended_action else None
-        if not include_oss_context:
-            data.pop("reasoning_chain", None)
-            data.pop("similar_incidents", None)
-            data.pop("rag_similarity_score", None)
-            data.pop("decision_tree", None)
-            data.pop("alternative_actions", None)
-            data.pop("infrastructure_intent", None)
-        data["deterministic_id"] = self.deterministic_id
-        data["age_seconds"] = self.age_seconds
-        data["is_executable"] = self.is_executable
-        data["is_oss_advisory"] = self.is_oss_advisory
-        data["requires_enterprise_upgrade"] = self.requires_enterprise_upgrade
-        data["version"] = self.VERSION
-        data["confidence_interval"] = self.confidence_interval
-        return data
-
-    def with_execution_result(self, execution_id: str, executed_at: float, result: Dict[str, Any],
-                              status: IntentStatus = IntentStatus.COMPLETED, metadata: Optional[Dict[str, Any]] = None) -> "HealingIntent":
-        return HealingIntent(
-            action=self.action, component=self.component, parameters=self.parameters, justification=self.justification,
-            confidence=self.confidence, confidence_distribution=self.confidence_distribution, incident_id=self.incident_id,
-            detected_at=self.detected_at, risk_score=self.risk_score, risk_factors=self.risk_factors,
-            cost_projection=self.cost_projection, cost_confidence_interval=self.cost_confidence_interval,
-            recommended_action=self.recommended_action, decision_tree=self.decision_tree,
-            alternative_actions=self.alternative_actions, risk_profile=self.risk_profile,
-            reasoning_chain=self.reasoning_chain, similar_incidents=self.similar_incidents,
-            rag_similarity_score=self.rag_similarity_score, source=self.source, intent_id=self.intent_id,
-            created_at=self.created_at, oss_edition=self.oss_edition, oss_license=self.oss_license,
-            requires_enterprise=self.requires_enterprise, execution_allowed=self.execution_allowed,
-            infrastructure_intent_id=self.infrastructure_intent_id, policy_violations=self.policy_violations,
-            infrastructure_intent=self.infrastructure_intent, status=status, execution_id=execution_id,
-            executed_at=executed_at, execution_result=result,
-            enterprise_metadata={**(self.enterprise_metadata or {}), **(metadata or {})},
-            human_overrides=self.human_overrides, approvals=self.approvals, comments=self.comments
-        )
-
-    def with_human_approval(self, approver: str, approval_time: float, comments: Optional[str] = None,
-                            overrides: Optional[Dict[str, Any]] = None) -> "HealingIntent":
-        approval_record = {"approver": approver, "timestamp": approval_time, "comments": comments, "overrides": overrides}
-        new_overrides = list(self.human_overrides)
-        if overrides:
-            new_overrides.append({"overrider": approver, "timestamp": approval_time, "overrides": overrides, "reason": comments})
-        new_approvals = list(self.approvals) + [approval_record]
-        new_comments = list(self.comments)
-        if comments:
-            new_comments.append({"author": approver, "timestamp": approval_time, "comment": comments})
-        return HealingIntent(
-            action=self.action, component=self.component, parameters=self.parameters, justification=self.justification,
-            confidence=self.confidence, confidence_distribution=self.confidence_distribution, incident_id=self.incident_id,
-            detected_at=self.detected_at, risk_score=self.risk_score, risk_factors=self.risk_factors,
-            cost_projection=self.cost_projection, cost_confidence_interval=self.cost_confidence_interval,
-            recommended_action=self.recommended_action, decision_tree=self.decision_tree,
-            alternative_actions=self.alternative_actions, risk_profile=self.risk_profile,
-            reasoning_chain=self.reasoning_chain, similar_incidents=self.similar_incidents,
-            rag_similarity_score=self.rag_similarity_score, source=self.source, intent_id=self.intent_id,
-            created_at=self.created_at, status=IntentStatus.APPROVED_WITH_OVERRIDES if overrides else IntentStatus.APPROVED,
-            execution_id=self.execution_id, executed_at=self.executed_at, execution_result=self.execution_result,
-            enterprise_metadata=self.enterprise_metadata, human_overrides=new_overrides, approvals=new_approvals,
-            comments=new_comments, oss_edition=self.oss_edition, oss_license=self.oss_license,
-            requires_enterprise=self.requires_enterprise, execution_allowed=self.execution_allowed,
-            infrastructure_intent_id=self.infrastructure_intent_id, policy_violations=self.policy_violations,
-            infrastructure_intent=self.infrastructure_intent
-        )
-
-    def mark_as_sent_to_enterprise(self) -> "HealingIntent":
-        return HealingIntent(
-            action=self.action, component=self.component, parameters=self.parameters, justification=self.justification,
-            confidence=self.confidence, confidence_distribution=self.confidence_distribution, incident_id=self.incident_id,
-            detected_at=self.detected_at, risk_score=self.risk_score, risk_factors=self.risk_factors,
-            cost_projection=self.cost_projection, cost_confidence_interval=self.cost_confidence_interval,
-            recommended_action=self.recommended_action, decision_tree=self.decision_tree,
-            alternative_actions=self.alternative_actions, risk_profile=self.risk_profile,
-            reasoning_chain=self.reasoning_chain, similar_incidents=self.similar_incidents,
-            rag_similarity_score=self.rag_similarity_score, source=self.source, intent_id=self.intent_id,
-            created_at=self.created_at, status=IntentStatus.PENDING_EXECUTION, execution_id=self.execution_id,
-            executed_at=self.executed_at, execution_result=self.execution_result, enterprise_metadata=self.enterprise_metadata,
-            human_overrides=self.human_overrides, approvals=self.approvals, comments=self.comments,
-            oss_edition=self.oss_edition, oss_license=self.oss_license, requires_enterprise=self.requires_enterprise,
-            execution_allowed=self.execution_allowed, infrastructure_intent_id=self.infrastructure_intent_id,
-            policy_violations=self.policy_violations, infrastructure_intent=self.infrastructure_intent
-        )
-
-    def mark_as_oss_advisory(self) -> "HealingIntent":
-        return HealingIntent(
-            action=self.action, component=self.component, parameters=self.parameters, justification=self.justification,
-            confidence=self.confidence, confidence_distribution=self.confidence_distribution, incident_id=self.incident_id,
-            detected_at=self.detected_at, risk_score=self.risk_score, risk_factors=self.risk_factors,
-            cost_projection=self.cost_projection, cost_confidence_interval=self.cost_confidence_interval,
-            recommended_action=self.recommended_action, decision_tree=self.decision_tree,
-            alternative_actions=self.alternative_actions, risk_profile=self.risk_profile,
-            reasoning_chain=self.reasoning_chain, similar_incidents=self.similar_incidents,
-            rag_similarity_score=self.rag_similarity_score, source=self.source, intent_id=self.intent_id,
-            created_at=self.created_at, status=IntentStatus.OSS_ADVISORY_ONLY, execution_id=self.execution_id,
-            executed_at=self.executed_at, execution_result=self.execution_result, enterprise_metadata=self.enterprise_metadata,
-            human_overrides=self.human_overrides, approvals=self.approvals, comments=self.comments,
-            oss_edition=self.oss_edition, oss_license=self.oss_license, requires_enterprise=self.requires_enterprise,
-            execution_allowed=False, infrastructure_intent_id=self.infrastructure_intent_id,
-            policy_violations=self.policy_violations, infrastructure_intent=self.infrastructure_intent
-        )
-
-    @classmethod
-    def from_infrastructure_intent(cls, infrastructure_intent: Any, action: str, component: str,
-                                   parameters: Dict[str, Any], justification: str, confidence: float = 0.85,
-                                   risk_score: Optional[float] = None, risk_factors: Optional[Dict[str, float]] = None,
-                                   cost_projection: Optional[float] = None, policy_violations: Optional[List[str]] = None,
-                                   recommended_action: Optional[RecommendedAction] = None,
-                                   source: IntentSource = IntentSource.INFRASTRUCTURE_ANALYSIS) -> "HealingIntent":
-        infrastructure_intent_id = getattr(infrastructure_intent, 'intent_id', None)
-        if hasattr(infrastructure_intent, 'model_dump'):
-            intent_dict = infrastructure_intent.model_dump()
-        elif hasattr(infrastructure_intent, 'to_dict'):
-            intent_dict = infrastructure_intent.to_dict()
-        else:
-            intent_dict = {"type": str(type(infrastructure_intent))}
-        return cls(
-            action=action, component=component, parameters=parameters, justification=justification, confidence=confidence,
-            risk_score=risk_score, risk_factors=risk_factors, cost_projection=cost_projection,
-            policy_violations=policy_violations or [], recommended_action=recommended_action, source=source,
-            infrastructure_intent_id=infrastructure_intent_id, infrastructure_intent=intent_dict,
-            oss_edition=OSS_EDITION, requires_enterprise=True, execution_allowed=False
-        )
-
-    @classmethod
-    def from_analysis(cls, action: str, component: str, parameters: Dict[str, Any], justification: str,
-                      confidence: float, confidence_std: float = 0.05,
-                      similar_incidents: Optional[List[Dict[str, Any]]] = None,
-                      reasoning_chain: Optional[List[Dict[str, Any]]] = None, incident_id: str = "",
-                      source: IntentSource = IntentSource.OSS_ANALYSIS, rag_similarity_score: Optional[float] = None,
-                      risk_score: Optional[float] = None, cost_projection: Optional[float] = None) -> "HealingIntent":
-        if similar_incidents and len(similar_incidents) > cls.MAX_SIMILAR_INCIDENTS:
-            similar_incidents = similar_incidents[:cls.MAX_SIMILAR_INCIDENTS]
-        conf_dist = ConfidenceDistribution(confidence, confidence_std)
-        enhanced_confidence = confidence
-        if similar_incidents:
-            similarity_scores = [inc.get("similarity", 0.0) for inc in similar_incidents if "similarity" in inc]
-            if similarity_scores:
-                avg_similarity = sum(similarity_scores) / len(similarity_scores)
-                confidence_boost = min(0.2, avg_similarity * 0.3)
-                enhanced_confidence = min(confidence * (1.0 + confidence_boost), cls.MAX_CONFIDENCE)
-        final_rag_score = rag_similarity_score
-        if final_rag_score is None and similar_incidents and len(similar_incidents) > 0:
-            top_similarities = [inc.get("similarity", 0.0) for inc in similar_incidents[:3] if "similarity" in inc]
-            if top_similarities:
-                final_rag_score = sum(top_similarities) / len(top_similarities)
-        return cls(
-            action=action, component=component, parameters=parameters, justification=justification,
-            confidence=enhanced_confidence, confidence_distribution=conf_dist.to_dict(), incident_id=incident_id,
-            similar_incidents=similar_incidents, reasoning_chain=reasoning_chain, rag_similarity_score=final_rag_score,
-            source=source, risk_score=risk_score, cost_projection=cost_projection,
-            oss_edition=OSS_EDITION, requires_enterprise=True, execution_allowed=False
-        )
-
-    @classmethod
-    def from_rag_recommendation(cls, action: str, component: str, parameters: Dict[str, Any],
-                                rag_similarity_score: float, similar_incidents: List[Dict[str, Any]],
-                                justification_template: str = "Based on {count} similar historical incidents with {success_rate:.0%} success rate",
-                                success_rate: Optional[float] = None, risk_score: Optional[float] = None,
-                                cost_projection: Optional[float] = None) -> "HealingIntent":
-        if not similar_incidents:
-            raise ValidationError("RAG recommendation requires similar incidents")
-        if success_rate is None:
-            if len(similar_incidents) == 0:
-                success_rate = 0.0
-            else:
-                successful = sum(1 for inc in similar_incidents if inc.get("success", False))
-                success_rate = successful / len(similar_incidents)
-        justification = justification_template.format(count=len(similar_incidents), success_rate=success_rate or 0.0,
-                                                      action=action, component=component)
-        base_confidence = rag_similarity_score * 0.8
-        if success_rate:
-            base_confidence = base_confidence * (0.7 + success_rate * 0.3)
-        return cls.from_analysis(action=action, component=component, parameters=parameters, justification=justification,
-                                  confidence=min(base_confidence, 0.95), similar_incidents=similar_incidents,
-                                  incident_id=similar_incidents[0].get("incident_id", "") if similar_incidents else "",
-                                  source=IntentSource.RAG_SIMILARITY, rag_similarity_score=rag_similarity_score,
-                                  risk_score=risk_score, cost_projection=cost_projection)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "HealingIntent":
-        version = data.get("version", "1.0.0")
-        clean_data = data.copy()
-        if "source" in clean_data and isinstance(clean_data["source"], str):
-            clean_data["source"] = IntentSource(clean_data["source"])
-        if "status" in clean_data and isinstance(clean_data["status"], str):
-            clean_data["status"] = IntentStatus(clean_data["status"])
-        if "recommended_action" in clean_data and isinstance(clean_data["recommended_action"], str):
-            try:
-                clean_data["recommended_action"] = RecommendedAction(clean_data["recommended_action"])
-            except ValueError:
-                clean_data["recommended_action"] = None
-        clean_data.pop("deterministic_id", None)
-        clean_data.pop("age_seconds", None)
-        clean_data.pop("is_executable", None)
-        clean_data.pop("is_oss_advisory", None)
-        clean_data.pop("requires_enterprise_upgrade", None)
-        clean_data.pop("version", None)
-        clean_data.pop("confidence_interval", None)
-        return cls(**clean_data)
-
-    def _normalize_parameters(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        normalized: Dict[str, Any] = {}
-        for key, value in sorted(params.items()):
-            normalized[key] = self._normalize_value(value)
-        return normalized
-
-    def _normalize_value(self, value: Any) -> Any:
-        if isinstance(value, (int, float, str, bool, type(None))):
-            return value
-        elif isinstance(value, (list, tuple, set)):
-            return tuple(sorted(self._normalize_value(v) for v in value))
-        elif isinstance(value, dict):
-            return self._normalize_parameters(value)
-        elif hasattr(value, '__dict__'):
-            return self._normalize_parameters(value.__dict__)
-        else:
-            try:
-                return str(value)
-            except Exception:
-                return f"<unserializable:{type(value).__name__}>"
-
-    def get_oss_context(self) -> Dict[str, Any]:
-        return {
-            "reasoning_chain": self.reasoning_chain,
-            "similar_incidents": self.similar_incidents,
-            "rag_similarity_score": self.rag_similarity_score,
-            "decision_tree": self.decision_tree,
-            "alternative_actions": self.alternative_actions,
-            "analysis_timestamp": datetime.fromtimestamp(self.detected_at).isoformat(),
-            "source": self.source.value,
-            "created_at": datetime.fromtimestamp(self.created_at).isoformat(),
-            "oss_edition": self.oss_edition,
-            "is_oss_advisory": self.is_oss_advisory,
-            "infrastructure_intent": self.infrastructure_intent,
-        }
-
-    def get_execution_summary(self) -> Dict[str, Any]:
-        summary = {
-            "intent_id": self.deterministic_id,
-            "action": self.action,
-            "component": self.component,
-            "confidence": self.confidence,
-            "confidence_interval": self.confidence_interval,
-            "risk_score": self.risk_score,
-            "cost_projection": self.cost_projection,
-            "status": self.status.value,
-            "created_at": datetime.fromtimestamp(self.created_at).isoformat(),
-            "age_seconds": self.age_seconds,
-            "oss_edition": self.oss_edition,
-            "requires_enterprise": self.requires_enterprise,
-            "is_oss_advisory": self.is_oss_advisory,
-            "source": self.source.value,
-            "policy_violations_count": len(self.policy_violations) if self.policy_violations else 0,
-            "confidence_basis": self._get_confidence_basis(),
-        }
-        if self.executed_at:
-            summary["executed_at"] = datetime.fromtimestamp(self.executed_at).isoformat()
-            summary["execution_duration_seconds"] = self.executed_at - self.created_at
-        if self.execution_result:
-            summary["execution_success"] = self.execution_result.get("success", False)
-            summary["execution_message"] = self.execution_result.get("message", "")
-        if self.rag_similarity_score:
-            summary["rag_similarity_score"] = self.rag_similarity_score
-        if self.similar_incidents:
-            summary["similar_incidents_count"] = len(self.similar_incidents)
-        if self.approvals:
-            summary["approvals_count"] = len(self.approvals)
-            summary["approved_by"] = [a.get("approver") for a in self.approvals if a.get("approver")]
-        if self.human_overrides:
-            summary["overrides_count"] = len(self.human_overrides)
-        return summary
-
-    def is_immutable(self) -> bool:
-        try:
-            object.__setattr__(self, '_test_immutable', True)
-            return False
-        except Exception:
-            return True
-
-    def __repr__(self) -> str:
-        return (f"HealingIntent(id={self.deterministic_id[:8]}..., action={self.action}, "
-                f"component={self.component}, confidence={self.confidence:.2f}, "
-                f"risk={self.risk_score:.2f if self.risk_score else 'N/A'}, status={self.status.value})")
-
-class HealingIntentSerializer:
-    SCHEMA_VERSION: ClassVar[str] = "2.0.0"
-
-    @classmethod
-    def serialize(cls, intent: HealingIntent, version: str = "2.0.0") -> Dict[str, Any]:
-        try:
-            if version == "2.0.0":
-                return {
-                    "version": version,
-                    "schema_version": cls.SCHEMA_VERSION,
-                    "data": intent.to_dict(include_oss_context=True),
-                    "metadata": {
-                        "serialized_at": time.time(),
-                        "deterministic_id": intent.deterministic_id,
-                        "is_executable": intent.is_executable,
-                        "is_oss_advisory": intent.is_oss_advisory,
-                        "requires_enterprise_upgrade": intent.requires_enterprise_upgrade,
-                        "oss_edition": intent.oss_edition,
-                        "has_probabilistic_confidence": intent.confidence_distribution is not None,
-                        "has_risk_assessment": intent.risk_score is not None,
-                        "has_cost_projection": intent.cost_projection is not None,
-                    }
-                }
-            elif version in ["1.1.0", "1.0.0"]:
-                data = intent.to_dict(include_oss_context=True)
-                data.pop("confidence_distribution", None)
-                data.pop("risk_score", None)
-                data.pop("risk_factors", None)
-                data.pop("cost_projection", None)
-                data.pop("cost_confidence_interval", None)
-                data.pop("recommended_action", None)
-                data.pop("decision_tree", None)
-                data.pop("alternative_actions", None)
-                data.pop("risk_profile", None)
-                data.pop("human_overrides", None)
-                data.pop("approvals", None)
-                data.pop("comments", None)
-                data.pop("infrastructure_intent_id", None)
-                data.pop("policy_violations", None)
-                data.pop("infrastructure_intent", None)
-                if data.get("status") in [
-                    IntentStatus.EXECUTING_PARTIAL.value,
-                    IntentStatus.COMPLETED_PARTIAL.value,
-                    IntentStatus.ROLLED_BACK.value,
-                    IntentStatus.PENDING_APPROVAL.value,
-                    IntentStatus.APPROVED.value,
-                    IntentStatus.APPROVED_WITH_OVERRIDES.value
-                ]:
-                    data["status"] = IntentStatus.PENDING_EXECUTION.value
-                return {
-                    "version": version,
-                    "schema_version": "1.1.0" if version == "1.1.0" else "1.0.0",
-                    "data": data,
-                    "metadata": {
-                        "serialized_at": time.time(),
-                        "deterministic_id": intent.deterministic_id,
-                        "is_executable": intent.is_executable,
-                        "is_oss_advisory": intent.is_oss_advisory,
-                    }
-                }
-            else:
-                raise SerializationError(f"Unsupported version: {version}")
-        except Exception as e:
-            raise SerializationError(f"Failed to serialize HealingIntent: {e}") from e
-
-    @classmethod
-    def deserialize(cls, data: Dict[str, Any]) -> HealingIntent:
-        try:
-            version = data.get("version", "1.0.0")
-            intent_data = data.get("data", data)
-            if version in ["2.0.0", "1.1.0", "1.0.0"]:
-                if version.startswith("1."):
-                    intent_data.setdefault("confidence_distribution", None)
-                    intent_data.setdefault("risk_score", None)
-                    intent_data.setdefault("risk_factors", None)
-                    intent_data.setdefault("cost_projection", None)
-                    intent_data.setdefault("cost_confidence_interval", None)
-                    intent_data.setdefault("recommended_action", None)
-                    intent_data.setdefault("decision_tree", None)
-                    intent_data.setdefault("alternative_actions", None)
-                    intent_data.setdefault("risk_profile", None)
-                    intent_data.setdefault("human_overrides", [])
-                    intent_data.setdefault("approvals", [])
-                    intent_data.setdefault("comments", [])
-                    intent_data.setdefault("infrastructure_intent_id", None)
-                    intent_data.setdefault("policy_violations", [])
-                    intent_data.setdefault("infrastructure_intent", None)
-                return HealingIntent.from_dict(intent_data)
-            else:
-                raise SerializationError(f"Unsupported version: {version}")
-        except KeyError as e:
-            raise SerializationError(f"Missing required field in serialized data: {e}") from e
-        except Exception as e:
-            raise SerializationError(f"Failed to deserialize HealingIntent: {e}") from e
-
-    @classmethod
-    def to_json(cls, intent: HealingIntent, pretty: bool = False) -> str:
-        try:
-            serialized = cls.serialize(intent)
-            return json.dumps(serialized, indent=2 if pretty else None, default=str)
-        except Exception as e:
-            raise SerializationError(f"Failed to convert to JSON: {e}") from e
-
-    @classmethod
-    def from_json(cls, json_str: str) -> HealingIntent:
-        try:
-            data = json.loads(json_str)
-            return cls.deserialize(data)
-        except json.JSONDecodeError as e:
-            raise SerializationError(f"Invalid JSON: {e}") from e
-        except Exception as e:
-            raise SerializationError(f"Failed to parse JSON: {e}") from e
-
-    @classmethod
-    def to_enterprise_json(cls, intent: HealingIntent) -> str:
-        try:
-            enterprise_request = intent.to_enterprise_request()
-            return json.dumps(enterprise_request, default=str)
-        except Exception as e:
-            raise SerializationError(f"Failed to create Enterprise JSON: {e}") from e
-
-    @classmethod
-    def validate_for_oss(cls, intent: HealingIntent) -> bool:
-        try:
-            if intent.oss_edition != OSS_EDITION:
-                return False
-            if intent.execution_allowed:
-                return False
-            if intent.similar_incidents and len(intent.similar_incidents) > HealingIntent.MAX_SIMILAR_INCIDENTS:
-                return False
-            if not intent.is_immutable():
-                return False
-            if intent.executed_at is not None or intent.execution_id is not None:
-                return False
-            return True
-        except Exception:
-            return False
-
-# Factory functions
-def create_infrastructure_healing_intent(infrastructure_result: Any, action_mapping: Optional[Dict[str, str]] = None) -> HealingIntent:
-    if action_mapping is None:
-        action_mapping = {"approve": "execute", "deny": "block", "escalate": "escalate", "defer": "defer"}
-    recommended_action = getattr(infrastructure_result, 'recommended_action', None)
-    if recommended_action and hasattr(recommended_action, 'value'):
-        action = action_mapping.get(recommended_action.value, "review")
-    else:
-        action = "review"
-    parameters = {
-        "infrastructure_intent_id": getattr(infrastructure_result, 'intent_id', None),
-        "risk_score": getattr(infrastructure_result, 'risk_score', None),
-        "cost_projection": getattr(infrastructure_result, 'cost_projection', None),
-        "policy_violations": getattr(infrastructure_result, 'policy_violations', []),
-        "evaluation_details": getattr(infrastructure_result, 'evaluation_details', {})
-    }
-    justification_parts = [getattr(infrastructure_result, 'justification', "Infrastructure analysis completed")]
-    policy_violations = getattr(infrastructure_result, 'policy_violations', [])
-    if policy_violations:
-        justification_parts.append(f"Policy violations: {'; '.join(policy_violations)}")
-    return HealingIntent.from_infrastructure_intent(
-        infrastructure_intent=getattr(infrastructure_result, 'infrastructure_intent', None),
-        action=action,
-        component="infrastructure",
-        parameters=parameters,
-        justification=" ".join(justification_parts),
-        confidence=getattr(infrastructure_result, 'confidence_score', 0.85),
-        risk_score=getattr(infrastructure_result, 'risk_score', None),
-        policy_violations=policy_violations,
-        recommended_action=recommended_action,
-        source=IntentSource.INFRASTRUCTURE_ANALYSIS
-    ).mark_as_oss_advisory()
-
-def create_rollback_intent(component: str, revision: str = "previous", justification: str = "",
-                           incident_id: str = "", similar_incidents: Optional[List[Dict[str, Any]]] = None,
-                           rag_similarity_score: Optional[float] = None, risk_score: Optional[float] = None,
-                           cost_projection: Optional[float] = None) -> HealingIntent:
-    if not justification:
-        justification = f"Rollback {component} to {revision} revision"
-    return HealingIntent.from_analysis(
-        action="rollback",
-        component=component,
-        parameters={"revision": revision},
-        justification=justification,
-        confidence=0.9,
-        similar_incidents=similar_incidents,
-        incident_id=incident_id,
-        rag_similarity_score=rag_similarity_score,
-        risk_score=risk_score,
-        cost_projection=cost_projection,
-    ).mark_as_oss_advisory()
-
-def create_restart_intent(component: str, container_id: Optional[str] = None, justification: str = "",
-                          incident_id: str = "", similar_incidents: Optional[List[Dict[str, Any]]] = None,
-                          rag_similarity_score: Optional[float] = None, risk_score: Optional[float] = None,
-                          cost_projection: Optional[float] = None) -> HealingIntent:
-    parameters = {}
-    if container_id:
-        parameters["container_id"] = container_id
-    if not justification:
-        justification = f"Restart container for {component}"
-    return HealingIntent.from_analysis(
-        action="restart_container",
-        component=component,
-        parameters=parameters,
-        justification=justification,
-        confidence=0.85,
-        similar_incidents=similar_incidents,
-        incident_id=incident_id,
-        rag_similarity_score=rag_similarity_score,
-        risk_score=risk_score,
-        cost_projection=cost_projection,
-    ).mark_as_oss_advisory()
-
-def create_scale_out_intent(component: str, scale_factor: int = 2, justification: str = "",
-                            incident_id: str = "", similar_incidents: Optional[List[Dict[str, Any]]] = None,
-                            rag_similarity_score: Optional[float] = None, risk_score: Optional[float] = None,
-                            cost_projection: Optional[float] = None) -> HealingIntent:
-    if not justification:
-        justification = f"Scale out {component} by factor {scale_factor}"
-    return HealingIntent.from_analysis(
-        action="scale_out",
-        component=component,
-        parameters={"scale_factor": scale_factor},
-        justification=justification,
-        confidence=0.8,
-        similar_incidents=similar_incidents,
-        incident_id=incident_id,
-        rag_similarity_score=rag_similarity_score,
-        risk_score=risk_score,
-        cost_projection=cost_projection,
-    ).mark_as_oss_advisory()
-
-def create_oss_advisory_intent(action: str, component: str, parameters: Dict[str, Any], justification: str,
-                               confidence: float = 0.85, incident_id: str = "", risk_score: Optional[float] = None,
-                               cost_projection: Optional[float] = None) -> HealingIntent:
-    return HealingIntent(
-        action=action,
-        component=component,
-        parameters=parameters,
-        justification=justification,
-        confidence=confidence,
-        incident_id=incident_id,
-        risk_score=risk_score,
-        cost_projection=cost_projection,
-        oss_edition=OSS_EDITION,
-        requires_enterprise=True,
-        execution_allowed=False,
-        status=IntentStatus.OSS_ADVISORY_ONLY,
-    )
-
-__all__ = [
-    "HealingIntent",
-    "ConfidenceDistribution",
-    "HealingIntentSerializer",
-    "IntentSource",
-    "IntentStatus",
-    "RecommendedAction",
-    "HealingIntentError",
-    "SerializationError",
-    "ValidationError",
-    "create_infrastructure_healing_intent",
-    "create_rollback_intent",
-    "create_restart_intent",
-    "create_scale_out_intent",
-    "create_oss_advisory_intent",
-]

infrastructure/intents.py

@@ -1,168 +0,0 @@
-# agentic_reliability_framework/infrastructure/intents.py
-"""
-Infrastructure Intent Schema – Algebraic Data Types for Change Requests.
-
-This module defines a family of intents as a discriminated union. Each intent
-represents a proposed infrastructure action. Intents are immutable, self-validating,
-and carry provenance for auditability.
-
-The design follows principles of domain-driven design and knowledge engineering,
-using strong typing and semantic constraints to prevent invalid states.
-"""
-
-from __future__ import annotations
-
-import uuid
-from datetime import datetime
-from enum import Enum
-from typing import Annotated, Any, Dict, Literal, Optional, Union
-
-from pydantic import BaseModel, Field, field_validator
-from pydantic.functional_validators import AfterValidator
-
-# -----------------------------------------------------------------------------
-# Domain Primitives (NewTypes for type safety)
-# -----------------------------------------------------------------------------
-# These are simple wrappers that enforce type checks at runtime only if validators are added.
-# Here we use them as markers; actual validation occurs in field validators.
-Region = str
-Size = str
-Principal = str
-ResourceScope = str
-ServiceName = str
-ChangeScope = Literal["single_instance", "canary", "global"]
-Environment = Literal["dev", "staging", "prod", "test"]
-
-# -----------------------------------------------------------------------------
-# Enums for fixed sets (but extensible via new variants)
-# -----------------------------------------------------------------------------
-class ResourceType(str, Enum):
-    """Azure resource types with semantic meaning."""
-    VM = "vm"
-    STORAGE_ACCOUNT = "storage_account"
-    DATABASE = "database"
-    KUBERNETES_CLUSTER = "kubernetes_cluster"
-    FUNCTION_APP = "function_app"
-    VIRTUAL_NETWORK = "virtual_network"
-
-    # We could add methods here to return associated pricing categories, etc.
-
-class PermissionLevel(str, Enum):
-    """Access permission levels in increasing order of privilege."""
-    READ = "read"
-    WRITE = "write"
-    ADMIN = "admin"
-
-# -----------------------------------------------------------------------------
-# Knowledge Base Stubs (simulated – in production would be loaded from external source)
-# -----------------------------------------------------------------------------
-# These are used for semantic validation. In a real system, they would be fetched
-# from Azure APIs or a configuration service.
-VALID_AZURE_REGIONS = {
-    "eastus", "eastus2", "westus", "westeurope", "northeurope",
-    "southeastasia", "eastasia", "japaneast", "brazilsouth"
-}
-
-# Mapping of resource type to plausible size patterns (simplified)
-RESOURCE_SIZE_PATTERNS = {
-    ResourceType.VM: {"Standard_D2s_v3", "Standard_D4s_v3", "Standard_D8s_v3", "Standard_D16s_v3"},
-    ResourceType.STORAGE_ACCOUNT: {"50GB", "100GB", "1TB", "10TB"},
-    ResourceType.DATABASE: {"Basic", "Standard", "Premium"},
-    ResourceType.KUBERNETES_CLUSTER: {"Small", "Medium", "Large"},
-    ResourceType.FUNCTION_APP: {"Consumption", "Premium"},
-    ResourceType.VIRTUAL_NETWORK: {"default"},
-}
-
-# -----------------------------------------------------------------------------
-# Base Intent Class
-# -----------------------------------------------------------------------------
-class Intent(BaseModel):
-    """Abstract base for all intents, providing common fields."""
-    intent_id: str = Field(default_factory=lambda: str(uuid.uuid4()), description="Unique identifier for this intent")
-    timestamp: datetime = Field(default_factory=datetime.utcnow, description="Time the intent was created")
-    requester: Principal = Field(..., description="User or service principal requesting the action")
-    provenance: Dict[str, Any] = Field(
-        default_factory=dict,
-        description="Metadata about how the intent was generated (e.g., agent ID, session)"
-    )
-
-    class Config:
-        frozen = True  # immutable after creation
-        extra = "forbid"  # no extra fields
-
-# -----------------------------------------------------------------------------
-# Specific Intent Types
-# -----------------------------------------------------------------------------
-class ProvisionResourceIntent(Intent):
-    """Request to provision a new Azure resource."""
-    intent_type: Literal["provision_resource"] = "provision_resource"
-    resource_type: ResourceType
-    region: Region
-    size: Size
-    configuration: Dict[str, Any] = Field(default_factory=dict)
-    environment: Environment
-
-    @field_validator("region")
-    def validate_region(cls, v: Region) -> Region:
-        if v not in VALID_AZURE_REGIONS:
-            raise ValueError(f"Unknown Azure region: {v}")
-        return v
-
-    @field_validator("size")
-    def validate_size(cls, v: Size, info) -> Size:
-        # info.data contains previously validated fields
-        resource_type = info.data.get("resource_type")
-        if resource_type and resource_type in RESOURCE_SIZE_PATTERNS:
-            if v not in RESOURCE_SIZE_PATTERNS[resource_type]:
-                raise ValueError(f"Invalid size '{v}' for resource type {resource_type}")
-        return v
-
-class DeployConfigurationIntent(Intent):
-    """Request to change configuration of an existing service."""
-    intent_type: Literal["deploy_config"] = "deploy_config"
-    service_name: ServiceName
-    change_scope: ChangeScope
-    deployment_target: Environment
-    risk_level_hint: Optional[Annotated[float, Field(ge=0, le=1)]] = None
-    configuration: Dict[str, Any] = Field(default_factory=dict)
-
-    # Optional: validate that service_name follows naming conventions
-    @field_validator("service_name")
-    def validate_service_name(cls, v: ServiceName) -> ServiceName:
-        if not v or len(v) < 3:
-            raise ValueError("Service name must be at least 3 characters")
-        return v
-
-class GrantAccessIntent(Intent):
-    """Request to grant a permission to a principal."""
-    intent_type: Literal["grant_access"] = "grant_access"
-    principal: Principal
-    permission_level: PermissionLevel
-    resource_scope: ResourceScope
-    justification: Optional[str] = None
-
-    # Validate resource_scope format (simplified)
-    @field_validator("resource_scope")
-    def validate_resource_scope(cls, v: ResourceScope) -> ResourceScope:
-        if not v.startswith("/"):
-            raise ValueError("Resource scope must start with '/'")
-        return v
-
-# -----------------------------------------------------------------------------
-# Discriminated Union of All Intents
-# -----------------------------------------------------------------------------
-InfrastructureIntent = Annotated[
-    Union[ProvisionResourceIntent, DeployConfigurationIntent, GrantAccessIntent],
-    Field(discriminator="intent_type")
-]
-
-__all__ = [
-    "ResourceType",
-    "PermissionLevel",
-    "Environment",
-    "ChangeScope",
-    "ProvisionResourceIntent",
-    "DeployConfigurationIntent",
-    "GrantAccessIntent",
-    "InfrastructureIntent",
-]

infrastructure/policies.py

@@ -1,171 +0,0 @@
-"""
-Policy Algebra – Composable, typed policies for infrastructure governance.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Protocol, Set, TypeVar, Union
-
-from pydantic import BaseModel
-
-# Relative imports for intents
-from .intents import (
-    InfrastructureIntent,
-    ProvisionResourceIntent,
-    GrantAccessIntent,
-    ResourceType,
-    PermissionLevel,
-    Environment,
-)
-
-Violation = str
-EvalResult = List[Violation]
-
-class Policy(ABC):
-    @abstractmethod
-    def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-        pass
-
-    def __and__(self, other: Policy) -> Policy:
-        return AndPolicy(self, other)
-
-    def __or__(self, other: Policy) -> Policy:
-        return OrPolicy(self, other)
-
-    def __invert__(self) -> Policy:
-        return NotPolicy(self)
-
-class AtomicPolicy(Policy, ABC):
-    pass
-
-@dataclass(frozen=True)
-class RegionAllowedPolicy(AtomicPolicy):
-    allowed_regions: Set[str]
-
-    def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-        if isinstance(intent, ProvisionResourceIntent):
-            if intent.region not in self.allowed_regions:
-                return [f"Region '{intent.region}' not allowed. Allowed: {self.allowed_regions}"]
-        return []
-
-@dataclass(frozen=True)
-class ResourceTypeRestrictedPolicy(AtomicPolicy):
-    forbidden_types: Set[ResourceType]
-
-    def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-        if isinstance(intent, ProvisionResourceIntent):
-            if intent.resource_type in self.forbidden_types:
-                return [f"Resource type '{intent.resource_type.value}' is forbidden."]
-        return []
-
-@dataclass(frozen=True)
-class MaxPermissionLevelPolicy(AtomicPolicy):
-    max_level: PermissionLevel
-
-    _LEVEL_ORDER = {
-        PermissionLevel.READ: 1,
-        PermissionLevel.WRITE: 2,
-        PermissionLevel.ADMIN: 3,
-    }
-
-    def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-        if isinstance(intent, GrantAccessIntent):
-            if self._LEVEL_ORDER[intent.permission_level] > self._LEVEL_ORDER[self.max_level]:
-                return [f"Permission level '{intent.permission_level.value}' exceeds max allowed '{self.max_level.value}'."]
-        return []
-
-@dataclass(frozen=True)
-class CostThresholdPolicy(AtomicPolicy):
-    max_cost_usd: float
-
-    def evaluate(self, intent: InfrastructureIntent, cost: Optional[float] = None) -> EvalResult:
-        return []
-
-@dataclass(frozen=True)
-class AndPolicy(Policy):
-    left: Policy
-    right: Policy
-
-    def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-        return self.left.evaluate(intent) + self.right.evaluate(intent)
-
-@dataclass(frozen=True)
-class OrPolicy(Policy):
-    left: Policy
-    right: Policy
-
-    def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-        left_violations = self.left.evaluate(intent)
-        right_violations = self.right.evaluate(intent)
-        if not left_violations or not right_violations:
-            return []
-        return left_violations + right_violations
-
-@dataclass(frozen=True)
-class NotPolicy(Policy):
-    inner: Policy
-
-    def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-        inner_violations = self.inner.evaluate(intent)
-        if inner_violations:
-            return []
-        else:
-            return ["Condition not met (NOT policy)"]
-
-class PolicyEvaluator:
-    def __init__(self, root_policy: Policy):
-        self._root = root_policy
-
-    def evaluate(self, intent: InfrastructureIntent, context: Optional[Dict[str, Any]] = None) -> EvalResult:
-        return self._evaluate_recursive(self._root, intent, context or {})
-
-    def _evaluate_recursive(self, policy: Policy, intent: InfrastructureIntent, context: Dict[str, Any]) -> EvalResult:
-        if isinstance(policy, CostThresholdPolicy):
-            cost = context.get('cost_estimate')
-            if cost is not None and cost > policy.max_cost_usd:
-                return [f"Cost ${cost:.2f} exceeds threshold ${policy.max_cost_usd:.2f}"]
-            return []
-        if isinstance(policy, AtomicPolicy):
-            return policy.evaluate(intent)
-        if isinstance(policy, AndPolicy):
-            return self._evaluate_recursive(policy.left, intent, context) + self._evaluate_recursive(policy.right, intent, context)
-        if isinstance(policy, OrPolicy):
-            left = self._evaluate_recursive(policy.left, intent, context)
-            right = self._evaluate_recursive(policy.right, intent, context)
-            if not left or not right:
-                return []
-            return left + right
-        if isinstance(policy, NotPolicy):
-            inner = self._evaluate_recursive(policy.inner, intent, context)
-            if inner:
-                return []
-            return ["Condition not met (NOT policy)"]
-        return []
-
-def allow_all() -> Policy:
-    class _AllowAll(AtomicPolicy):
-        def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-            return []
-    return _AllowAll()
-
-def deny_all() -> Policy:
-    class _DenyAll(AtomicPolicy):
-        def evaluate(self, intent: InfrastructureIntent) -> EvalResult:
-            return ["Action denied by default policy"]
-    return _DenyAll()
-
-__all__ = [
-    "Policy",
-    "RegionAllowedPolicy",
-    "ResourceTypeRestrictedPolicy",
-    "MaxPermissionLevelPolicy",
-    "CostThresholdPolicy",
-    "AndPolicy",
-    "OrPolicy",
-    "NotPolicy",
-    "PolicyEvaluator",
-    "allow_all",
-    "deny_all",
-]

infrastructure/risk_engine.py

@@ -1,105 +0,0 @@
-"""
-Risk Scoring Engine – Multi-factor probabilistic risk model.
-"""
-
-from typing import Dict, List, Optional, Tuple, Any, Callable
-from dataclasses import dataclass, field
-
-from .intents import (
-    InfrastructureIntent,
-    ProvisionResourceIntent,
-    GrantAccessIntent,
-    DeployConfigurationIntent,
-    PermissionLevel,
-    Environment,
-)
-
-@dataclass(frozen=True)
-class RiskFactor:
-    name: str
-    weight: float
-    score_fn: Callable[[InfrastructureIntent, Optional[float], List[str]], float]
-    description: str = ""
-
-    def __call__(self, intent: InfrastructureIntent, cost: Optional[float], violations: List[str]) -> float:
-        return self.score_fn(intent, cost, violations)
-
-def intent_type_factor(intent: InfrastructureIntent, cost: Optional[float], violations: List[str]) -> float:
-    mapping = {
-        "provision_resource": 0.1,
-        "grant_access": 0.3,
-        "deploy_config": 0.2,
-    }
-    return mapping.get(intent.intent_type, 0.1)
-
-def cost_factor(intent: InfrastructureIntent, cost: Optional[float], violations: List[str]) -> float:
-    if not isinstance(intent, ProvisionResourceIntent) or cost is None:
-        return 0.0
-    return min(cost / 5000.0, 1.0)
-
-def permission_factor(intent: InfrastructureIntent, cost: Optional[float], violations: List[str]) -> float:
-    if not isinstance(intent, GrantAccessIntent):
-        return 0.0
-    mapping = {
-        PermissionLevel.READ: 0.1,
-        PermissionLevel.WRITE: 0.4,
-        PermissionLevel.ADMIN: 0.8,
-    }
-    return mapping.get(intent.permission_level, 0.5)
-
-def scope_factor(intent: InfrastructureIntent, cost: Optional[float], violations: List[str]) -> float:
-    if not isinstance(intent, DeployConfigurationIntent):
-        return 0.0
-    mapping = {
-        "single_instance": 0.1,
-        "canary": 0.2,
-        "global": 0.6,
-    }
-    return mapping.get(intent.change_scope, 0.3)
-
-def environment_factor(intent: InfrastructureIntent, cost: Optional[float], violations: List[str]) -> float:
-    if hasattr(intent, "environment") and intent.environment == Environment.PROD:
-        return 0.1
-    return 0.0
-
-def policy_violation_factor(intent: InfrastructureIntent, cost: Optional[float], violations: List[str]) -> float:
-    return min(len(violations) * 0.2, 0.8)
-
-class RiskEngine:
-    DEFAULT_FACTORS = [
-        RiskFactor("intent_type", 1.0, intent_type_factor, "Base risk from intent type"),
-        RiskFactor("cost", 0.3, cost_factor, "Normalized cost estimate"),
-        RiskFactor("permission", 0.3, permission_factor, "Permission level being granted"),
-        RiskFactor("scope", 0.2, scope_factor, "Deployment scope"),
-        RiskFactor("environment", 0.1, environment_factor, "Production environment"),
-        RiskFactor("policy_violations", 0.2, policy_violation_factor, "Number of policy violations"),
-    ]
-
-    def __init__(self, factors: Optional[List[RiskFactor]] = None):
-        self.factors = factors if factors is not None else self.DEFAULT_FACTORS
-
-    def calculate_risk(
-        self,
-        intent: InfrastructureIntent,
-        cost_estimate: Optional[float],
-        policy_violations: List[str],
-    ) -> Tuple[float, str, Dict[str, float]]:
-        total = 0.0
-        contributions = {}
-
-        for factor in self.factors:
-            raw_score = factor(intent, cost_estimate, policy_violations)
-            weighted = raw_score * factor.weight
-            contributions[factor.name] = weighted
-            total += weighted
-
-        total = max(0.0, min(total, 1.0))
-
-        lines = [f"Total risk score: {total:.2f}"]
-        for factor in self.factors:
-            contrib = contributions[factor.name]
-            if contrib > 0.0:
-                lines.append(f"  - {factor.name}: {contrib:.2f} ({factor.description})")
-        explanation = "\n".join(lines)
-
-        return total, explanation, contributions