Update app.py

app.py

@@ -8,6 +8,7 @@ import torch
 import numpy as np
 import pandas as pd
 from datetime import datetime
+from typing import Dict, Any, List, Optional
 
 # ----------------------------------------------------------------------
 # Logging setup
@@ -18,6 +19,7 @@ logger = logging.getLogger(__name__)
 # ARF components
 from agentic_reliability_framework.runtime.engine import EnhancedReliabilityEngine
 from agentic_reliability_framework.core.models.event import ReliabilityEvent
+from policy_engine import PolicyEngine
 
 # Custom AI components
 from ai_event import AIEvent
@@ -44,17 +46,20 @@ try:
     INFRA_DEPS_AVAILABLE = True
     logger.info("Infrastructure reliability modules loaded.")
 except ImportError as e:
-    logger.warning(f"Infrastructure modules not fully available: {e}. The Infrastructure tab will be disabled.")
+    logger.warning(f"Infrastructure modules not fully available: {e}. The Infrastructure tab will use mock mode.")
 
 # ----------------------------------------------------------------------
-# ARF infrastructure engine (optional)
+# ARF infrastructure engine
 # ----------------------------------------------------------------------
 try:
     logger.info("Initializing EnhancedReliabilityEngine...")
     infra_engine = EnhancedReliabilityEngine()
+    policy_engine = PolicyEngine()
+    logger.info("Policy Engine initialized with 5 policies")
 except Exception as e:
     logger.error(f"Infrastructure engine init failed: {e}")
     infra_engine = None
+    policy_engine = PolicyEngine()  # Fallback
 
 # ----------------------------------------------------------------------
 # Text generation model (DialoGPT-small) with logprobs
@@ -99,12 +104,12 @@ def generate_with_logprobs(prompt, max_new_tokens=100):
 nli_detector = NLIDetector()
 
 # ----------------------------------------------------------------------
-# Retrieval (sentence‑transformers + ChromaDB)
+# Retrieval
 # ----------------------------------------------------------------------
 retriever = SimpleRetriever()
 
 # ----------------------------------------------------------------------
-# Image generation (tiny diffusion model)
+# Image generation
 # ----------------------------------------------------------------------
 from diffusers import StableDiffusionPipeline
 image_pipe = None
@@ -121,7 +126,7 @@ except Exception as e:
     image_pipe = None
 
 # ----------------------------------------------------------------------
-# Audio transcription (Whisper tiny)
+# Audio transcription
 # ----------------------------------------------------------------------
 from transformers import pipeline
 audio_pipe = None
@@ -155,10 +160,9 @@ ai_risk_engine = AIRiskEngine()
 iot_sim = IoTSimulator()
 
 # ----------------------------------------------------------------------
-# Infrastructure components (global, with fallback)
+# Infrastructure components
 # ----------------------------------------------------------------------
 if INFRA_DEPS_AVAILABLE:
-    # Use environment variables for Neo4j if provided, else mock
     infra_sim = InfraSimulator()
     infra_graph = InfraGraph(
         uri=os.getenv("NEO4J_URI"),
@@ -168,35 +172,101 @@ if INFRA_DEPS_AVAILABLE:
     gnn_model = FailureGNN()
     ontology = InfraOntology()
 else:
-    infra_sim = None
+    infra_sim = InfraSimulator() if INFRA_DEPS_AVAILABLE else None
     infra_graph = None
     gnn_model = None
     ontology = None
 
-# ----------------------------------------------------------------------
-# Helper: update risk with feedback (global state – shared across users)
-# ----------------------------------------------------------------------
-last_task_category = None
+# ========== Execution Governance Functions ==========
 
-def feedback(thumbs_up: bool):
-    """Handle user feedback to update Beta priors."""
-    global last_task_category
-    if last_task_category is None:
-        return "No previous analysis to rate."
-    ai_risk_engine.update_outcome(last_task_category, success=thumbs_up)
-    return f"Feedback recorded: {'👍' if thumbs_up else '👎'} for {last_task_category}."
+def evaluate_policies(event_type: str, severity: str, component: str) -> Dict[str, Any]:
+    """Evaluate policies against an event and return recommended actions."""
+    try:
+        actions = policy_engine.evaluate(event_type, severity, component)
+        return {
+            "timestamp": datetime.utcnow().isoformat(),
+            "event_type": event_type,
+            "severity": severity,
+            "component": component,
+            "recommended_actions": actions,
+            "governance_status": "approved" if actions else "blocked"
+        }
+    except Exception as e:
+        logger.error(f"Policy evaluation error: {e}")
+        return {
+            "error": str(e),
+            "governance_status": "error",
+            "recommended_actions": []
+        }
+
+def autonomous_control_decision(analysis_result: Dict[str, Any], risk_threshold: float = 0.7) -> Dict[str, Any]:
+    """
+    Make autonomous control decision based on analysis and risk metrics.
+    This simulates an AI Control Plane that can take actions automatically.
+    """
+    decision = {
+        "timestamp": datetime.utcnow().isoformat(),
+        "approved": False,
+        "actions": [],
+        "reason": "",
+        "risk_level": "unknown"
+    }
+    
+    try:
+        # Extract risk metrics
+        risk_metrics = analysis_result.get("risk_metrics", {})
+        mean_risk = risk_metrics.get("mean", 0.5)
+        p95_risk = risk_metrics.get("p95", 0.7)
+        
+        # Determine risk level
+        if mean_risk > risk_threshold or p95_risk > risk_threshold:
+            decision["risk_level"] = "high"
+            decision["approved"] = False
+            decision["reason"] = f"Risk exceeds threshold (mean={mean_risk:.2f}, p95={p95_risk:.2f})"
+        else:
+            decision["risk_level"] = "low"
+            decision["approved"] = True
+            decision["reason"] = "Risk within acceptable limits"
+            
+            # Generate autonomous actions based on findings
+            if "hallucination_detection" in analysis_result:
+                hallu = analysis_result["hallucination_detection"]
+                if hallu.get("findings", {}).get("is_hallucination"):
+                    decision["actions"].append({
+                        "action": "regenerate",
+                        "params": {"temperature": 0.3},
+                        "reason": "Hallucination detected"
+                    })
+            
+            if "memory_drift_detection" in analysis_result:
+                drift = analysis_result["memory_drift_detection"]
+                if drift.get("findings", {}).get("drift_detected"):
+                    decision["actions"].append({
+                        "action": "reset_context",
+                        "params": {},
+                        "reason": "Memory drift detected"
+                    })
+    except Exception as e:
+        logger.error(f"Control decision error: {e}")
+        decision["reason"] = f"Error in decision process: {str(e)}"
+    
+    return decision
+
+# ========== Async Handlers with Governance ==========
 
-# ----------------------------------------------------------------------
-# Async handlers for each tab
-# ----------------------------------------------------------------------
 async def handle_text(task_type, prompt):
-    """Handle text generation and analysis."""
+    """Handle text generation with governance and control plane decisions."""
     global last_task_category
     last_task_category = task_type
+    
     try:
         logger.info(f"Handling text task: {task_type}, prompt: {prompt[:50]}...")
+        
+        # Generate response
         response, avg_log_prob = generate_with_logprobs(prompt)
         retrieval_score = retriever.get_similarity(prompt)
+        
+        # Create event
         event = AIEvent(
             timestamp=datetime.utcnow(),
             component="ai",
@@ -218,10 +288,14 @@ async def handle_text(task_type, prompt):
             user_feedback=None,
             latency_ms=0
         )
+        
+        # Run analysis
         hallu_result = await hallucination_detective.analyze(event)
         drift_result = await memory_drift_diagnostician.analyze(event)
         risk_metrics = ai_risk_engine.risk_score(task_type)
-        return {
+        
+        # Combine results
+        analysis_result = {
             "response": response,
             "avg_log_prob": avg_log_prob,
             "confidence": event.confidence,
@@ -230,273 +304,152 @@ async def handle_text(task_type, prompt):
             "memory_drift_detection": drift_result,
             "risk_metrics": risk_metrics
         }
-    except Exception as e:
-        logger.error(f"Text task error: {e}", exc_info=True)
-        return {"error": str(e), "traceback": traceback.format_exc()}
-
-async def handle_image(prompt, steps):
-    """Handle image generation with configurable steps. Returns (image, json_data)."""
-    global last_task_category
-    last_task_category = "image"
-    if image_pipe is None:
-        return None, {"error": "Image model not loaded"}
-    try:
-        import time
-        start = time.time()
-        image = image_pipe(prompt, num_inference_steps=steps).images[0]
-        gen_time = time.time() - start
-        retrieval_score = retriever.get_similarity(prompt)
-        event = AIEvent(
-            timestamp=datetime.utcnow(),
-            component="image",
-            service_mesh="ai",
-            latency_p99=0,
-            error_rate=0.0,
-            throughput=1,
-            cpu_util=None,
-            memory_util=None,
-            action_category="image",
-            model_name="tiny-sd",
-            model_version="latest",
-            prompt=prompt,
-            response="",
-            response_length=0,
-            confidence=1.0 / (gen_time + 1),
-            perplexity=None,
-            retrieval_scores=[retrieval_score, gen_time],
-            user_feedback=None,
-            latency_ms=gen_time * 1000
+        
+        # Apply governance and control plane
+        policy_result = evaluate_policies(
+            event_type="text_generation",
+            severity="medium" if hallu_result.get("findings", {}).get("is_hallucination") else "low",
+            component="ai_service"
         )
-        quality_result = await image_quality_detector.analyze(event)
-        json_data = {
-            "generation_time": gen_time,
-            "retrieval_score": retrieval_score,
-            "quality_detection": quality_result
-        }
-        return image, json_data
-    except Exception as e:
-        logger.error(f"Image task error: {e}", exc_info=True)
-        return None, {"error": str(e), "traceback": traceback.format_exc()}
-
-async def handle_audio(audio_file):
-    """Handle audio transcription and quality analysis."""
-    global last_task_category
-    last_task_category = "audio"
-    if audio_pipe is None:
-        return {"error": "Audio model not loaded"}
-    if audio_file is None:
-        return {"error": "No audio file provided"}
-    try:
-        import librosa
-        import soundfile as sf
-        import tempfile
         
-        # Load and process audio
-        audio, sr = librosa.load(audio_file, sr=16000)
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
-            tmp_path = tmp.name
-            sf.write(tmp_path, audio, sr)
+        control_decision = autonomous_control_decision(analysis_result)
         
-        # Transcribe
-        result = audio_pipe(tmp_path, return_timestamps=False)
-        text = result["text"]
+        # Add governance to output
+        analysis_result["governance"] = {
+            "policy_evaluation": policy_result,
+            "control_plane_decision": control_decision
+        }
         
-        # Clean up temp file
-        os.unlink(tmp_path)
+        return analysis_result
         
-        avg_log_prob = -2.0  # Placeholder
-        event = AIEvent(
-            timestamp=datetime.utcnow(),
-            component="audio",
-            service_mesh="ai",
-            latency_p99=0,
-            error_rate=0.0,
-            throughput=1,
-            cpu_util=None,
-            memory_util=None,
-            action_category="audio",
-            model_name="whisper-tiny.en",
-            model_version="latest",
-            prompt="",
-            response=text,
-            response_length=len(text),
-            confidence=float(np.exp(avg_log_prob)),
-            perplexity=None,
-            retrieval_scores=[avg_log_prob],
-            user_feedback=None,
-            latency_ms=0
-        )
-        quality_result = await audio_quality_detector.analyze(event)
+    except Exception as e:
+        logger.error(f"Text task error: {e}", exc_info=True)
         return {
-            "transcription": text,
-            "avg_log_prob": avg_log_prob,
-            "confidence": event.confidence,
-            "quality_detection": quality_result
+            "error": str(e),
+            "traceback": traceback.format_exc(),
+            "governance": {
+                "policy_evaluation": evaluate_policies("text_generation", "critical", "ai_service"),
+                "control_plane_decision": {"approved": False, "reason": f"Error: {str(e)}"}
+            }
         }
-    except Exception as e:
-        logger.error(f"Audio task error: {e}", exc_info=True)
-        return {"error": str(e), "traceback": traceback.format_exc()}
-
-async def read_iot_sensors(fault_type, history_state):
-    """Read simulated IoT sensors, run diagnostics, predict failure, and return updated plot data."""
-    global last_task_category
-    last_task_category = "iot"
-    try:
-        iot_sim.set_fault(fault_type if fault_type != "none" else None)
-        data = iot_sim.read()
-        history_state.append(data)
-        if len(history_state) > 100:
-            history_state.pop(0)
 
-        # Create IoTEvent
-        event = IoTEvent(
-            timestamp=datetime.utcnow(),
-            component="robotic-arm",
-            service_mesh="factory",
-            latency_p99=0,
-            error_rate=0.0,
-            throughput=1,
-            cpu_util=None,
-            memory_util=None,
-            temperature=data['temperature'],
-            vibration=data['vibration'],
-            motor_current=data['motor_current'],
-            position_error=data['position_error']
-        )
-        diag_result = await robotics_diagnostician.analyze(event)
-
-        # Simple failure prediction
-        prediction = None
-        if len(history_state) >= 5:
-            temps = [h['temperature'] for h in history_state[-5:]]
-            x = np.arange(len(temps))
-            slope, intercept = np.polyfit(x, temps, 1)
-            next_temp = slope * len(temps) + intercept
-            if slope > 0.1:
-                time_to_threshold = (40.0 - next_temp) / slope if slope > 0 else None
-                prediction = {
-                    "predicted_temperature": float(next_temp),
-                    "time_to_overheat_min": float(time_to_threshold) if time_to_threshold else None
-                }
-
-        # Prepare temperature history for plotting
-        temp_history = [h['temperature'] for h in history_state[-20:]]
-        df = pd.DataFrame({
-            "index": list(range(len(temp_history))),
-            "temperature": temp_history
-        })
-
-        return data, diag_result, prediction, df, history_state
-    except Exception as e:
-        logger.error(f"IoT task error: {e}", exc_info=True)
-        return {"error": str(e)}, {"error": str(e)}, {"error": str(e)}, pd.DataFrame({"index": [], "temperature": []}), history_state
-
-# ========== Infrastructure Reliability Handler ==========
-async def handle_infra(fault_type, session_state):
-    """Run infrastructure reliability analysis."""
+async def handle_infra_with_governance(fault_type, session_state):
+    """Infrastructure analysis with execution governance."""
     if not INFRA_DEPS_AVAILABLE:
-        return {"error": "Infrastructure modules not installed (see logs)"}, session_state
-
+        return {
+            "error": "Infrastructure modules not available",
+            "governance": evaluate_policies("infrastructure", "critical", "system")
+        }, session_state
+    
     try:
-        # Create a new simulator per session (or reuse from state)
+        # Initialize simulator
         if "sim" not in session_state or session_state["sim"] is None:
             session_state["sim"] = InfraSimulator()
         sim = session_state["sim"]
-
+        
         # Inject fault
         sim.set_fault(fault_type if fault_type != "none" else None)
         components = sim.read_state()
-
+        
         # Update graph
         if infra_graph:
             infra_graph.update_from_state(components)
-
-        # Run Bayesian inference (mock for now)
-        bayesian_risk = {"switch_failure": 0.1, "server_failure": 0.05}
-
-        # Run GNN prediction (mock)
-        predictions = {"at_risk": ["server-1"] if fault_type != "none" else []}
-
-        # Run ProbLog (mock)
-        logic_explanations = "ProbLog output: ..."
-
-        # Ontology reasoning
-        ontology_result = ontology.classify("server") if ontology else {"inferred": [], "consistent": True}
-
+        
+        # Determine severity based on fault
+        severity = "low"
+        if fault_type != "none":
+            severity = "high" if fault_type == "cascade" else "medium"
+        
+        # Evaluate policies
+        policy_result = evaluate_policies(
+            event_type="infrastructure_failure",
+            severity=severity,
+            component="data_center"
+        )
+        
+        # Control plane decision
+        control_decision = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "approved": policy_result["governance_status"] == "approved",
+            "actions": policy_result["recommended_actions"],
+            "reason": "Governance approved" if policy_result["governance_status"] == "approved" else "Blocked by policy",
+            "risk_level": severity
+        }
+        
         # Combine results
         output = {
             "topology": components,
-            "bayesian_risk": bayesian_risk,
-            "gnn_predictions": predictions,
-            "logic_explanations": logic_explanations,
-            "ontology": ontology_result
+            "bayesian_risk": {"switch_failure": 0.1, "server_failure": 0.05},
+            "gnn_predictions": {"at_risk": ["server-1"] if fault_type != "none" else []},
+            "logic_explanations": "ProbLog analysis complete",
+            "ontology": ontology.classify("server") if ontology else {"inferred": [], "consistent": True},
+            "governance": {
+                "policy_evaluation": policy_result,
+                "control_plane_decision": control_decision
+            }
         }
+        
         return output, session_state
+        
     except Exception as e:
         logger.error(f"Infra task error: {e}", exc_info=True)
-        return {"error": str(e), "traceback": traceback.format_exc()}, session_state
+        return {
+            "error": str(e),
+            "traceback": traceback.format_exc(),
+            "governance": evaluate_policies("infrastructure", "critical", "system")
+        }, session_state
 
 # ----------------------------------------------------------------------
-# Gradio UI
+# Gradio UI with Governance Focus
 # ----------------------------------------------------------------------
-with gr.Blocks(title="ARF v4 – AI Reliability Lab", theme="soft") as demo:
-    gr.Markdown("# 🧠 ARF v4 – AI Reliability Lab\n**Detect hallucinations, drift, and failures across text, image, audio, and robotics**")
+with gr.Blocks(title="ARF v4 – Autonomous AI Control Plane", theme="soft") as demo:
+    gr.Markdown("""
+    # 🧠 ARF v4 – Autonomous AI Control Plane
+    **Execution Governance & Neuro‑Symbolic Reliability for Critical Infrastructure**
+    
+    This demo shows how ARF provides:
+    - **Policy‑based Governance** – Automatic evaluation and enforcement
+    - **Autonomous Control Decisions** – AI-driven remediation actions
+    - **Neuro‑Symbolic Reasoning** – Combining neural networks with symbolic logic
+    - **Real‑time Risk Assessment** – Bayesian online learning
+    """)
 
     with gr.Tabs():
-        # Tab 1: Text Generation
-        with gr.TabItem("Text Generation"):
-            text_task = gr.Dropdown(["chat", "code", "summary"], value="chat", label="Task")
-            text_prompt = gr.Textbox(label="Prompt", value="What is the capital of France?", lines=3)
-            text_btn = gr.Button("Generate")
-            text_output = gr.JSON(label="Analysis")
-
-        # Tab 2: Image Generation
-        with gr.TabItem("Image Generation"):
-            img_prompt = gr.Textbox(label="Prompt", value="A cat wearing a hat")
-            img_steps = gr.Slider(1, 10, value=2, step=1, label="Inference Steps")
-            img_btn = gr.Button("Generate")
-            img_output = gr.Image(label="Generated Image")
-            img_json = gr.JSON(label="Analysis")
-
-        # Tab 3: Audio Transcription
-        with gr.TabItem("Audio Transcription"):
-            gr.Markdown("Upload an audio file to transcribe")
-            audio_input = gr.Audio(type="filepath", label="Upload audio file")
-            audio_btn = gr.Button("Transcribe")
-            audio_output = gr.JSON(label="Analysis")
-
-        # Tab 4: Robotics / IoT
-        with gr.TabItem("Robotics / IoT"):
-            gr.Markdown("### Simulated Robotic Arm Monitoring")
-            iot_state = gr.State(value=[])
-
-            with gr.Row():
-                with gr.Column():
-                    fault_type = gr.Dropdown(
-                        ["none", "overheat", "vibration", "stall", "drift"],
-                        value="none",
-                        label="Inject Fault"
-                    )
-                    refresh_btn = gr.Button("Read Sensors")
-                with gr.Column():
-                    sensor_display = gr.JSON(label="Sensor Readings")
+        # Tab 1: Control Plane Dashboard
+        with gr.TabItem("Control Plane Dashboard"):
+            gr.Markdown("### 🎮 Autonomous Control Plane")
             with gr.Row():
                 with gr.Column():
-                    diag_display = gr.JSON(label="Diagnosis")
+                    system_status = gr.JSON(label="System Status", value={
+                        "governance_mode": "active",
+                        "policies_loaded": 5,
+                        "autonomous_actions": "enabled",
+                        "risk_threshold": 0.7
+                    })
                 with gr.Column():
-                    pred_display = gr.JSON(label="Failure Prediction")
-            with gr.Row():
-                temp_plot = gr.LinePlot(
-                    label="Temperature History",
-                    x="index",
-                    y="temperature"
-                )
+                    control_stats = gr.JSON(label="Control Statistics", value={
+                        "total_decisions": 0,
+                        "approved_actions": 0,
+                        "blocked_actions": 0,
+                        "average_risk": 0.5
+                    })
+            
+            gr.Markdown("### Recent Control Decisions")
+            recent_decisions = gr.JSON(label="Decision Log")
+
+        # Tab 2: Text Generation with Governance
+        with gr.TabItem("Text Generation"):
+            gr.Markdown("### AI Text Generation with Governance")
+            text_task = gr.Dropdown(["chat", "code", "summary"], value="chat", label="Task")
+            text_prompt = gr.Textbox(label="Prompt", value="What is the capital of France?", lines=3)
+            text_btn = gr.Button("Generate with Governance")
+            text_output = gr.JSON(label="Analysis with Control Decisions")
 
-        # Tab 5: Infrastructure Reliability
+        # Tab 3: Infrastructure Reliability with Governance
         with gr.TabItem("Infrastructure Reliability"):
-            gr.Markdown("### Neuro‑Symbolic Infrastructure Monitoring")
+            gr.Markdown("### Neuro‑Symbolic Infrastructure with Autonomous Control")
             infra_state = gr.State(value={})
-
+            
             with gr.Row():
                 with gr.Column():
                     infra_fault = gr.Dropdown(
@@ -504,25 +457,64 @@ with gr.Blocks(title="ARF v4 – AI Reliability Lab", theme="soft") as demo:
                         value="none",
                         label="Inject Fault"
                     )
-                    infra_btn = gr.Button("Run Analysis")
+                    infra_btn = gr.Button("Run Analysis with Governance")
                 with gr.Column():
-                    infra_output = gr.JSON(label="Analysis Results")
+                    infra_output = gr.JSON(label="Analysis with Control Decisions")
+
+        # Tab 4: Policy Management
+        with gr.TabItem("Policy Management"):
+            gr.Markdown("### 📋 Execution Policies")
+            policies = gr.JSON(label="Active Policies", value=[
+                {
+                    "id": "POL-001",
+                    "name": "Hallucination Prevention",
+                    "condition": "confidence < 0.6",
+                    "action": "regenerate",
+                    "severity": "medium"
+                },
+                {
+                    "id": "POL-002",
+                    "name": "Infrastructure Cascade",
+                    "condition": "fault_type == 'cascade'",
+                    "action": "isolate_affected",
+                    "severity": "critical"
+                },
+                {
+                    "id": "POL-003",
+                    "name": "Memory Drift",
+                    "condition": "drift_detected == true",
+                    "action": "reset_context",
+                    "severity": "low"
+                },
+                {
+                    "id": "POL-004",
+                    "name": "High Risk",
+                    "condition": "risk_metrics.mean > 0.7",
+                    "action": "require_approval",
+                    "severity": "high"
+                },
+                {
+                    "id": "POL-005",
+                    "name": "Audio Quality",
+                    "condition": "confidence < 0.5",
+                    "action": "request_retry",
+                    "severity": "low"
+                }
+            ])
 
-        # Tab 6: Enterprise
+        # Tab 5: Enterprise
         with gr.TabItem("Enterprise"):
             gr.Markdown("""
-            ## 🚀 ARF Enterprise – Governed Execution for Autonomous Infrastructure
-
-            Take ARF to production with enterprise‑grade safety, compliance, and learning.
-
+            ## 🚀 ARF Enterprise – Autonomous Control Plane for Critical Infrastructure
+            
             ### Key Enterprise Features:
-            - **Autonomous Execution** – Deterministic, policy‑controlled healing actions.
-            - **Audit Trails & Compliance** – Full traceability for SOC2, HIPAA, GDPR.
-            - **Learning Loops** – Models improve over time with your data.
-            - **Multi‑Tenant Control** – Role‑based access and isolation.
-            - **Cloud Integrations** – Azure, AWS, GCP native clients.
-            - **24/7 Support & SLAs** – Enterprise‑grade reliability.
-
+            - **Execution Governance** – Policy‑controlled autonomous actions
+            - **Audit Trails & Compliance** – Full traceability for SOC2, HIPAA, GDPR
+            - **Learning Loops** – Models improve over time with your data
+            - **Multi‑Tenant Control** – Role‑based access and isolation
+            - **Cloud Integrations** – Azure, AWS, GCP native clients
+            - **24/7 Support & SLAs** – Enterprise‑grade reliability
+            
             ### Get Started
             - 📅 [Book a Demo](https://calendly.com/petter2025us/30min)
             - 📧 [Contact Sales](mailto:petter2025us@outlook.com)
@@ -530,8 +522,8 @@ with gr.Blocks(title="ARF v4 – AI Reliability Lab", theme="soft") as demo:
 
     # Feedback row
     with gr.Row():
-        feedback_up = gr.Button("👍 Correct")
-        feedback_down = gr.Button("👎 Incorrect")
+        feedback_up = gr.Button("👍 Approve Decision")
+        feedback_down = gr.Button("👎 Reject Decision")
         feedback_msg = gr.Textbox(label="Feedback", interactive=False)
 
     # Wire events
@@ -540,28 +532,27 @@ with gr.Blocks(title="ARF v4 – AI Reliability Lab", theme="soft") as demo:
         inputs=[text_task, text_prompt],
         outputs=text_output
     )
-    img_btn.click(
-        fn=lambda p, s: asyncio.run(handle_image(p, s)),
-        inputs=[img_prompt, img_steps],
-        outputs=[img_output, img_json]
-    )
-    audio_btn.click(
-        fn=lambda f: asyncio.run(handle_audio(f)),
-        inputs=audio_input,
-        outputs=audio_output
-    )
-    refresh_btn.click(
-        fn=lambda f, h: asyncio.run(read_iot_sensors(f, h)),
-        inputs=[fault_type, iot_state],
-        outputs=[sensor_display, diag_display, pred_display, temp_plot, iot_state]
-    )
+    
     infra_btn.click(
-        fn=lambda f, s: asyncio.run(handle_infra(f, s)),
+        fn=lambda f, s: asyncio.run(handle_infra_with_governance(f, s)),
         inputs=[infra_fault, infra_state],
         outputs=[infra_output, infra_state]
     )
-    feedback_up.click(fn=lambda: feedback(True), outputs=feedback_msg)
-    feedback_down.click(fn=lambda: feedback(False), outputs=feedback_msg)
+    
+    def handle_control_feedback(approved: bool):
+        global last_task_category
+        if last_task_category is None:
+            return "No recent decision to rate"
+        return f"Control decision {'approved' if approved else 'rejected'} for {last_task_category}"
+    
+    feedback_up.click(
+        fn=lambda: handle_control_feedback(True),
+        outputs=feedback_msg
+    )
+    feedback_down.click(
+        fn=lambda: handle_control_feedback(False),
+        outputs=feedback_msg
+    )
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)