Upload folder using huggingface_hub

README.md

@@ -98,7 +98,7 @@ curl -X POST "http://localhost:8000/api/v1/v1/incidents/evaluate"   -H "Content-
     "justification": "Causal: If we apply restart_container instead of no_action, latency would change from 600.00 to 510.00 (Δ = -90.00). Based on heuristic causal model.",
     "confidence": 0.85,
     "risk_score": 0.54,
-    "status": "success"
+    "status": "oss_advisory_only"
   },
   "causal_explanation": {
     "factual_outcome": 600,

app/api/routes_admin.py

@@ -2,7 +2,7 @@
 Admin API endpoints for API key management and audit logs.
 These endpoints should be protected (e.g., by an admin API key) in production.
 """
-from fastapi import APIRouter, Depends, HTTPException, Query, Path, Body, Request
+from fastapi import APIRouter, Depends, HTTPException, Query, Path, Body, Request, Header
 from pydantic import BaseModel
 from typing import Optional
 from datetime import datetime
@@ -21,10 +21,10 @@ router = APIRouter(prefix="/admin", tags=["admin"])
 ADMIN_API_KEY = os.getenv("ARF_ADMIN_API_KEY")
 
 
-def verify_admin(admin_key: str = Query(..., alias="admin_key")):
+def verify_admin(x_admin_key: str = Header(..., alias="X-Admin-Key")):
     if not ADMIN_API_KEY:
         raise HTTPException(status_code=403, detail="Admin API is not configured")
-    if not secrets.compare_digest(admin_key, ADMIN_API_KEY):
+    if not secrets.compare_digest(x_admin_key, ADMIN_API_KEY):
         raise HTTPException(status_code=403, detail="Invalid admin key")
     return True
 
@@ -73,7 +73,7 @@ async def create_api_key(req: CreateKeyRequest, db: Session = Depends(get_db)):
 
 
 @router.get("/keys", dependencies=[Depends(verify_admin)])
-async def list_api_keys(limit: int = 100, offset: int = 0):
+async def list_api_keys(limit: int = Query(100, ge=0, le=1000), offset: int = Query(0, ge=0)):
     """Lists keys by a non-secret `key_id` (the key's pepper-HMAC lookup
     hash), never the plaintext key -- there is no plaintext key to show
     since the H-2 fix (api_keys are hashed at rest). Use `key_id` in the
@@ -184,7 +184,7 @@ async def get_audit_logs(
     api_key: str = Path(..., description="The API key to audit"),
     start_date: Optional[str] = Query(None),
     end_date: Optional[str] = Query(None),
-    limit: int = 100,
+    limit: int = Query(100, ge=0, le=1000),
 ):
     start = datetime.fromisoformat(start_date) if start_date else None
     end = datetime.fromisoformat(end_date) if end_date else None

app/api/routes_incidents.py

@@ -1,5 +1,5 @@
 """
-Incident evaluation endpoints — backward‑compatible Bayesian reroute.
+Incident evaluation endpoints.
 
 This module provides two incident‑related routes:
 
@@ -7,10 +7,12 @@ This module provides two incident‑related routes:
     Stores a ``ReliabilityEvent`` in an in‑memory history for auditing
     and debugging.
 * ``POST /api/v1/v1/incidents/evaluate``    **(deprecated)**
-    Former heuristic endpoint now **rerouted to the full Bayesian risk
-    engine**.  All callers should migrate to
-    ``POST /api/v1/intents/evaluate``, which returns richer metadata
-    including CUDL uncertainty decomposition and decision traces.
+    Heuristic risk score computed directly from the reported event via
+    ``RiskEngine.compute_risk_from_event`` -- not the Bayesian
+    conjugate/HMC path used by intent evaluation.  All callers should
+    migrate to ``POST /api/v1/intents/evaluate``, which returns richer
+    metadata including CUDL uncertainty decomposition and decision
+    traces.
 
 The local model duplicates (``ReliabilityEvent``, ``HealingAction``)
 have been removed; all types are imported from the canonical ARF core
@@ -84,7 +86,8 @@ async def evaluate_incident(
     quota: dict = Depends(enforce_quota),
 ) -> dict:
     """
-    Evaluate an incident using the **Bayesian risk engine**.
+    Evaluate an incident using a heuristic risk score computed directly
+    from the reported event's latency/error rate (not the Bayesian engine).
 
     .. deprecated:: 0.6.0
         Use ``POST /api/v1/intents/evaluate`` instead.  This endpoint
@@ -93,13 +96,12 @@ async def evaluate_incident(
 
     The following steps are performed:
 
-    1. Convert the ``ReliabilityEvent`` into a minimal
-       ``DeployConfigurationIntent`` via ``intent_adapter``.
-    2. Call ``risk_service.evaluate_intent()`` to obtain a Bayesian
-       risk score.
-    3. Generate a heuristic healing action based on the risk score.
-    4. Run the causal explainer for counter‑factual text.
-    5. Build a backward‑compatible response envelope.
+    1. Compute a heuristic risk score directly from the reported event's
+       ``latency_p99``/``error_rate`` via
+       ``RiskEngine.compute_risk_from_event``.
+    2. Generate a heuristic healing action based on that risk threshold.
+    3. Run the causal explainer for counter‑factual text.
+    4. Build a backward‑compatible response envelope.
 
     Parameters
     ----------
@@ -135,45 +137,22 @@ async def evaluate_incident(
 
     try:
         # ------------------------------------------------------------------
-        # Step 1 – Convert the event into an infrastructure intent
-        # ------------------------------------------------------------------
-        from app.services.intent_adapter import to_oss_intent
-        from app.services.risk_service import evaluate_intent
-
-        raw_intent = {
-            "intent_type": "deploy_config",
-            "environment": "prod",
-            "service_name": event.component,
-            "requester": "auto",
-            "change_scope": "global",
-            "deployment_target": "prod",
-            "configuration": {},
-            "provenance": {"source": "incident_evaluate"},
-        }
-        oss_intent = to_oss_intent(raw_intent)
-
-        # ------------------------------------------------------------------
-        # Step 2 – Bayesian risk evaluation
+        # Step 1 - Heuristic risk score computed directly from the event
         # ------------------------------------------------------------------
         risk_engine = request.app.state.risk_engine
-        result = evaluate_intent(
-            engine=risk_engine,
-            intent=oss_intent,
-            cost_estimate=None,
-            policy_violations=[],
-        )
+        risk_score = risk_engine.compute_risk_from_event(event)
 
         # ------------------------------------------------------------------
-        # Step 3 – Heuristic action selection based on risk threshold
+        # Step 2 - Heuristic action selection based on risk threshold
         # ------------------------------------------------------------------
         optimal_action = (
             HealingAction.RESTART_CONTAINER
-            if result["risk_score"] > 0.5
+            if risk_score > 0.5
             else HealingAction.NO_ACTION
         )
 
         # ------------------------------------------------------------------
-        # Step 4 – Causal explainer
+        # Step 3 - Causal explainer
         # ------------------------------------------------------------------
         causal_explainer = CausalExplainer()
         current_state = {
@@ -187,19 +166,19 @@ async def evaluate_incident(
         )
 
         # ------------------------------------------------------------------
-        # Step 5 – Build response envelope
+        # Step 4 - Build response envelope
         # ------------------------------------------------------------------
         healing_intent = {
             "action": optimal_action.value,
             "component": event.component,
             "parameters": {},
             "justification": (
-                f"Bayesian risk score: {result['risk_score']:.3f}. "
+                f"Risk score: {risk_score:.3f}. "
                 f"Causal: {causal_exp.explanation_text}"
             ),
-            "confidence": 1.0 - result.get("uncertainty", 0.0),
-            "risk_score": result["risk_score"],
-            "status": "success",
+            "confidence": 0.85,
+            "risk_score": risk_score,
+            "status": "oss_advisory_only",
         }
 
         response_data = {
@@ -220,7 +199,7 @@ async def evaluate_incident(
                 "best_action": optimal_action.value,
                 "expected_utility": 0.5,
                 "explanation": (
-                    "Decision based on Bayesian risk threshold > 0.5"
+                    "Heuristic decision based on latency/error thresholds"
                 ),
             },
         }

docs/authentication.md

@@ -21,7 +21,7 @@ Current status
   `POST /report_incident` and `GET /history` were reading/writing two _different_ Python lists
   with the same name, so `GET /history` had in fact always returned empty regardless of what was
   reported; both routers now share the one list in `app.core.storage`.
-- `routes_admin.py`: individual `/admin/*` endpoints require an `admin_key` query parameter,
+- `routes_admin.py`: individual `/admin/*` endpoints require an `X-Admin-Key` header,
   verified against `ARF_ADMIN_API_KEY` (`app/api/deps.py`, or the local `verify_admin`
   dependency in that router). Also fails closed if unset. Includes
   `POST /admin/keys/{key_id}/rotate` — deactivates a key and issues a new one on the same

docs/docs_endpoints.md

@@ -145,13 +145,13 @@ The endpoint uses the following rule to choose the action:
 
 ```text
 optimal_action = RESTART_CONTAINER
-if latency_p99 > 500 OR error_rate > 0.15
+if risk_score > 0.5
 else NO_ACTION
 ```
 
 In the implementation, this is encoded as:
 
-- `restart_container` when `latency_p99 > 500` or `error_rate > 0.15`
+- `restart_container` when the risk score (see below) is greater than `0.5`
 - `no_action` otherwise
 
 No probabilistic policy or learned policy is involved.

tests/test_incidents.py

@@ -35,4 +35,9 @@ def test_evaluate_incident_deprecated():
     body = resp.json()
     assert "deprecation_notice" in body
     assert "healing_intent" in body
-    assert body["healing_intent"]["risk_score"] is not None
+    healing_intent = body["healing_intent"]
+    # latency_norm = min(1.0, 450/1000) = 0.45; risk = 0.45*0.7 + 0.12*0.3 = 0.351
+    assert healing_intent["risk_score"] == pytest.approx(0.351)
+    assert healing_intent["action"] == "no_action"
+    assert healing_intent["confidence"] == 0.85
+    assert healing_intent["status"] == "oss_advisory_only"