actshield 0.9.0__py3-none-any.whl

actshield/incidents/__init__.py

@@ -0,0 +1,25 @@
+"""ActShield Incidents Engine Package (Phase 9)."""
+
+from actshield.incidents.incident import IncidentTimelineEntry, SecurityIncident
+from actshield.incidents.incident_engine import IncidentEngine, IncidentTimelineBuilder
+from actshield.incidents.incident_rules import IncidentCreationRule
+from actshield.incidents.incident_state import (
+    ALLOWED_TRANSITIONS,
+    IncidentSeverity,
+    IncidentState,
+    IncidentStateMachine,
+)
+
+__all__ = [
+    "IncidentTimelineEntry",
+    "SecurityIncident",
+    "IncidentEngine",
+    "IncidentTimelineBuilder",
+    "IncidentCreationRule",
+    "ALLOWED_TRANSITIONS",
+    "IncidentSeverity",
+    "IncidentState",
+    "IncidentStateMachine",
+]
+
+

actshield/incidents/incident.py

@@ -0,0 +1,94 @@
+"""Security Incident Model for ActShield Phase 9."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+from actshield.incidents.incident_state import IncidentSeverity, IncidentState
+from actshield.tracing.correlation import generate_id
+
+
+class IncidentTimelineEntry(BaseModel):
+    """A chronological causal entry within an incident storyline."""
+    timestamp: str = Field(..., description="ISO timestamp or formatted time")
+    stage: str = Field(..., description="Stage e.g. '01. INTENT', '03. CONTEXT', '07. ENFORCE'")
+    agent_id: Optional[str] = None
+    agent_name: Optional[str] = None
+    action: str = ""
+    detail: str = ""
+    taint_state: str = "CLEAN"
+    decision: Optional[str] = None
+    event_id: Optional[str] = None
+    actor_name: Optional[str] = None
+    incident_state: Optional[IncidentState] = None
+
+    @property
+    def actor(self) -> str:
+        return self.actor_name or self.agent_name or self.agent_id or "system"
+
+    @property
+    def reason(self) -> str:
+        return self.detail or self.action
+
+    @property
+    def state(self) -> IncidentState:
+        return self.incident_state or IncidentState.DETECTED
+
+
+class SecurityIncident(BaseModel):
+    """Complete causal security incident record."""
+    incident_id: str = Field(default_factory=lambda: generate_id("inc"))
+    title: str = Field(..., description="Summary title of the incident")
+    severity: IncidentSeverity = Field(default=IncidentSeverity.MEDIUM)
+    state: IncidentState = Field(default=IncidentState.DETECTED)
+    attack_type: str = Field(default="policy_violation", description="Classification e.g. 'indirect_prompt_injection', 'authority_escape'")
+    root_event_id: Optional[str] = None
+    trace_id: str = Field(default_factory=lambda: generate_id("trc"), description="Causal trace ID linking all events")
+    
+    # Affected security entities
+    affected_agents: List[str] = Field(default_factory=list)
+    affected_tasks: List[str] = Field(default_factory=list)
+    affected_resources: List[str] = Field(default_factory=list)
+    
+    # Causal context & taint state
+    context_source: Optional[str] = None
+    trust_state: str = "UNKNOWN"
+    taint_state: str = "CLEAN"
+    authority_violated: bool = False
+    
+    # Decisions & runtime evidence
+    policy_verdict: str = "BLOCK"
+    sensitive_operations_attempted: int = 0
+    sensitive_operations_executed: int = 0  # CRITICAL: 0 proves prevention held
+    
+    # Intelligence enrichments
+    ai_secura_summary: Optional[str] = None
+    apiris_signals: List[str] = Field(default_factory=list)
+    
+    # Lifecycle & timeline
+    timeline: List[IncidentTimelineEntry] = Field(default_factory=list)
+    remediation_notes: Optional[str] = None
+    regression_id: Optional[str] = None
+    secured_replay_verified: bool = False
+    
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+    @property
+    def target_agent_id(self) -> str:
+        return self.affected_agents[0] if self.affected_agents else ""
+
+    @property
+    def tool_name(self) -> str:
+        return self.affected_resources[0] if self.affected_resources else ""
+
+    @property
+    def root_cause(self) -> str:
+        return self.ai_secura_summary or self.remediation_notes or "Security boundary violation"
+
+
+

actshield/incidents/incident_engine.py

@@ -0,0 +1,163 @@
+"""Incident timeline builder and incident engine orchestrator for ActShield Phase 9."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from actshield.incidents.incident import IncidentTimelineEntry, SecurityIncident
+from actshield.incidents.incident_rules import IncidentCreationRule
+from actshield.incidents.incident_state import (
+    IncidentSeverity,
+    IncidentState,
+    IncidentStateMachine,
+)
+from actshield.tracing.correlation import generate_id
+
+
+class IncidentTimelineBuilder:
+    """Builds a structured causal storyline from correlated events."""
+
+    @staticmethod
+    def from_events(events: List[Dict[str, Any]]) -> List[IncidentTimelineEntry]:
+        timeline: List[IncidentTimelineEntry] = []
+        for i, evt in enumerate(events):
+            stage = f"0{i+1}. {evt.get('stage_name', evt.get('event_type', 'EVENT'))}"
+            timeline.append(IncidentTimelineEntry(
+                timestamp=str(evt.get("timestamp", datetime.now(timezone.utc).isoformat())),
+                stage=stage,
+                agent_id=evt.get("agent_id"),
+                agent_name=evt.get("agent_name"),
+                action=evt.get("action") or f"Called {evt.get('tool', 'tool')}",
+                detail=evt.get("detail") or evt.get("reason") or "Event executed in trace",
+                taint_state=evt.get("taint", "CLEAN"),
+                decision=evt.get("decision"),
+                event_id=evt.get("event_id"),
+            ))
+        return timeline
+
+
+class IncidentEngine:
+    """Manages continuous security incident generation, correlation, and lifecycle state."""
+
+    def __init__(self, guard: Optional[Any] = None) -> None:
+        self.guard = guard
+        self.incidents: Dict[str, SecurityIncident] = {}
+
+    def record_incident(self, incident: SecurityIncident) -> SecurityIncident:
+        """Explicitly register a SecurityIncident."""
+        self.incidents[incident.incident_id] = incident
+        return incident
+
+    def process_event(self, event: Dict[str, Any], related_events: Optional[List[Dict[str, Any]]] = None) -> Optional[SecurityIncident]:
+        """Evaluate an event for incident creation and causal linking."""
+        should_create, title, severity, attack_type = IncidentCreationRule.evaluate(event)
+        if not should_create:
+            return None
+
+        trace_id = event.get("trace_id") or generate_id("trc")
+        
+        # Check if active incident already exists for this trace
+        for existing in self.incidents.values():
+            if existing.trace_id == trace_id and existing.state not in (IncidentState.CLOSED, IncidentState.VALIDATED):
+                # Update existing incident
+                if event.get("agent_id") and event["agent_id"] not in existing.affected_agents:
+                    existing.affected_agents.append(event["agent_id"])
+                if event.get("resource") and event["resource"] not in existing.affected_resources:
+                    existing.affected_resources.append(event["resource"])
+                existing.updated_at = datetime.now(timezone.utc)
+                return existing
+
+        timeline_events = related_events or [event]
+        timeline = IncidentTimelineBuilder.from_events(timeline_events)
+
+        incident = SecurityIncident(
+            title=title or "Security Boundary Incident",
+            severity=severity,
+            state=IncidentState.DETECTED,
+            attack_type=attack_type or "unknown_threat",
+            root_event_id=event.get("event_id"),
+            trace_id=trace_id,
+            affected_agents=[event["agent_id"]] if event.get("agent_id") else [],
+            affected_tasks=[event["task_id"]] if event.get("task_id") else [],
+            affected_resources=[event["resource"]] if event.get("resource") else ([event["tool"]] if event.get("tool") else []),
+            context_source=event.get("context_source"),
+            trust_state=event.get("trust_level", "UNKNOWN"),
+            taint_state=event.get("taint", "CLEAN"),
+            authority_violated=bool(event.get("authority_violation", False)),
+            policy_verdict=event.get("decision", "BLOCK"),
+            sensitive_operations_attempted=1,
+            sensitive_operations_executed=1 if event.get("decision") == "ALLOW" and event.get("taint") == "TAINTED" else 0,
+            ai_secura_summary=event.get("ai_secura_summary") or event.get("threat_reason"),
+            timeline=timeline,
+        )
+
+        self.incidents[incident.incident_id] = incident
+        return incident
+
+    def transition_state(self, incident_id: str, target_state: IncidentState, remediation_notes: Optional[str] = None) -> SecurityIncident:
+        """Deterministically transition an incident's lifecycle state."""
+        if incident_id not in self.incidents:
+            raise KeyError(f"Incident with ID '{incident_id}' not found.")
+
+        incident = self.incidents[incident_id]
+        IncidentStateMachine.validate_transition(incident.state, target_state)
+        incident.state = target_state
+        if remediation_notes:
+            incident.remediation_notes = remediation_notes
+        incident.updated_at = datetime.now(timezone.utc)
+        return incident
+
+    def transition_incident_state(
+        self,
+        incident_id: str,
+        to_state: IncidentState,
+        actor: str = "system",
+        reason: str = "",
+    ) -> Optional[SecurityIncident]:
+        """Transition incident state and append a timeline entry."""
+        if incident_id not in self.incidents:
+            return None
+
+        incident = self.incidents[incident_id]
+        IncidentStateMachine.validate_transition(incident.state, to_state)
+        incident.state = to_state
+        if reason:
+            incident.remediation_notes = reason
+
+        entry = IncidentTimelineEntry(
+            timestamp=datetime.now(timezone.utc).isoformat(),
+            stage=f"Stage {to_state.value}",
+            agent_id=incident.target_agent_id,
+            action=f"Transitioned to {to_state.value}",
+            detail=reason or f"State changed to {to_state.value}",
+            actor_name=actor,
+            incident_state=to_state,
+        )
+        incident.timeline.append(entry)
+        incident.updated_at = datetime.now(timezone.utc)
+        return incident
+
+    def link_regression(self, incident_id: str, regression_id: str, secured_replay_passed: bool = True) -> SecurityIncident:
+        """Attach verified regression fixture to incident and advance state."""
+        if incident_id not in self.incidents:
+            raise KeyError(f"Incident with ID '{incident_id}' not found.")
+
+        incident = self.incidents[incident_id]
+        incident.regression_id = regression_id
+        incident.secured_replay_verified = secured_replay_passed
+        if secured_replay_passed:
+            incident.state = IncidentState.VALIDATED
+        incident.updated_at = datetime.now(timezone.utc)
+        return incident
+
+    def get_incident(self, incident_id: str) -> Optional[SecurityIncident]:
+        return self.incidents.get(incident_id)
+
+    def list_incidents(self, state: Optional[IncidentState] = None) -> List[SecurityIncident]:
+        if state:
+            return [inc for inc in self.incidents.values() if inc.state == state]
+        return list(self.incidents.values())
+
+
+

actshield/incidents/incident_rules.py

@@ -0,0 +1,116 @@
+"""Deterministic rules for automatic incident creation in ActShield Phase 9."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Tuple
+from actshield.incidents.incident_state import IncidentSeverity
+
+
+class IncidentCreationRule:
+    """Evaluates runtime security event signals to determine if an incident must be generated."""
+
+    @staticmethod
+    def evaluate(event: Dict[str, Any]) -> Tuple[bool, Optional[str], IncidentSeverity, Optional[str]]:
+        """
+        Evaluate an event dictionary or security payload.
+        Returns: (should_create_incident, title, severity, attack_type)
+        """
+        decision = str(event.get("decision", "")).upper()
+        taint = str(event.get("taint", "")).upper()
+        res_sens = str(event.get("resource_sensitivity", "")).upper()
+        auth_violation = bool(event.get("authority_violation", False))
+        bypass_detected = bool(event.get("bypass_detected", False))
+        attack_type = event.get("attack_type") or event.get("threat_type") or "policy_violation"
+
+        # Rule 1: CRITICAL INVARIANT — Actual unauthorized execution
+        if decision == "ALLOW" and (taint == "TAINTED" or auth_violation) and res_sens in ("HIGH", "CRITICAL"):
+            return (
+                True,
+                f"CRITICAL: Actual Unauthorized Execution on {event.get('resource', event.get('tool', 'Sensitive Resource'))}",
+                IncidentSeverity.CRITICAL,
+                "unauthorized_execution_bypass",
+            )
+
+        # Rule 2: Offensive Bypass Discovered
+        if bypass_detected:
+            return (
+                True,
+                f"Offensive Validation Bypass Detected: {event.get('variant_name', attack_type)}",
+                IncidentSeverity.HIGH,
+                "offensive_validation_bypass",
+            )
+
+        # Rule 3: Tainted context attempting high/critical resource
+        if taint in ("TAINTED", "UNTRUSTED") and (res_sens in ("HIGH", "CRITICAL") or decision == "BLOCK"):
+            return (
+                True,
+                f"Tainted Context Propagation to Sensitive Target: {event.get('tool', 'tool')}",
+                IncidentSeverity.HIGH,
+                "indirect_prompt_injection" if "injection" in attack_type.lower() else "tainted_data_propagation",
+            )
+
+        # Rule 4: Authority Boundary Escape Attempt
+        if auth_violation or "authority" in str(event.get("reason", "")).lower():
+            return (
+                True,
+                f"Delegated Authority Boundary Violation: {event.get('agent_id', 'Agent')} attempted {event.get('tool', 'action')}",
+                IncidentSeverity.MEDIUM,
+                "authority_escalation",
+            )
+
+        # Rule 5: Blocked Privileged Tool Execution
+        if decision == "BLOCK" and res_sens in ("HIGH", "CRITICAL"):
+            return (
+                True,
+                f"Blocked High-Risk Tool Request on {event.get('tool', 'tool')}",
+                IncidentSeverity.MEDIUM,
+                attack_type,
+            )
+
+        return (False, None, IncidentSeverity.LOW, None)
+
+    @staticmethod
+    def evaluate_threat_event(
+        threat_type: str,
+        severity: IncidentSeverity,
+        title: str,
+        description: str,
+        source_context_id: Optional[str] = None,
+        target_agent_id: Optional[str] = None,
+        tool_name: Optional[str] = None,
+        root_cause: Optional[str] = None,
+        evidence_event_ids: Optional[List[str]] = None,
+    ) -> Any:
+        """Construct a SecurityIncident directly from threat analysis signals."""
+        from actshield.incidents.incident import IncidentTimelineEntry, SecurityIncident
+        from actshield.incidents.incident_state import IncidentState
+        from datetime import datetime, timezone
+
+        timeline = [
+            IncidentTimelineEntry(
+                timestamp=datetime.now(timezone.utc).isoformat(),
+                stage="01. DETECTED",
+                agent_id=target_agent_id,
+                action=f"Detected {threat_type} on {tool_name or 'resource'}",
+                detail=description,
+                taint_state="UNTRUSTED",
+                decision="BLOCK",
+                actor_name="detection_engine",
+                incident_state=IncidentState.DETECTED,
+            )
+        ]
+
+        return SecurityIncident(
+            title=title,
+            severity=severity,
+            state=IncidentState.DETECTED,
+            attack_type=threat_type,
+            affected_agents=[target_agent_id] if target_agent_id else [],
+            affected_resources=[tool_name] if tool_name else [],
+            ai_secura_summary=root_cause or description,
+            timeline=timeline,
+            remediation_notes=root_cause,
+        )
+
+
+

actshield/incidents/incident_state.py

@@ -0,0 +1,58 @@
+"""Incident Lifecycle States and Deterministic State Transition Machine (Phase 9).
+
+Lifecycle:
+DETECTED -> TRIAGED -> INVESTIGATING -> CONTAINED -> REMEDIATED -> VALIDATED -> CLOSED
+
+Note:
+AI may provide analytical enrichment. Deterministic logic strictly governs state transitions.
+"""
+
+from enum import Enum
+from typing import List, Set
+
+
+class IncidentState(str, Enum):
+    """Deterministic security incident states."""
+    DETECTED = "DETECTED"
+    TRIAGED = "TRIAGED"
+    INVESTIGATING = "INVESTIGATING"
+    CONTAINED = "CONTAINED"
+    REMEDIATED = "REMEDIATED"
+    VALIDATED = "VALIDATED"
+    CLOSED = "CLOSED"
+
+
+class IncidentSeverity(str, Enum):
+    """Incident severity classification."""
+    LOW = "LOW"
+    MEDIUM = "MEDIUM"
+    HIGH = "HIGH"
+    CRITICAL = "CRITICAL"
+
+
+# Valid deterministic state transitions
+ALLOWED_TRANSITIONS: dict[IncidentState, Set[IncidentState]] = {
+    IncidentState.DETECTED: {IncidentState.TRIAGED, IncidentState.INVESTIGATING, IncidentState.CONTAINED, IncidentState.CLOSED},
+    IncidentState.TRIAGED: {IncidentState.INVESTIGATING, IncidentState.CONTAINED, IncidentState.CLOSED},
+    IncidentState.INVESTIGATING: {IncidentState.CONTAINED, IncidentState.REMEDIATED, IncidentState.CLOSED},
+    IncidentState.CONTAINED: {IncidentState.REMEDIATED, IncidentState.VALIDATED, IncidentState.CLOSED},
+    IncidentState.REMEDIATED: {IncidentState.VALIDATED, IncidentState.CLOSED, IncidentState.INVESTIGATING},
+    IncidentState.VALIDATED: {IncidentState.CLOSED, IncidentState.INVESTIGATING},
+    IncidentState.CLOSED: {IncidentState.INVESTIGATING},  # Reopen if needed
+}
+
+
+class IncidentStateMachine:
+    """Validates and enforces deterministic incident lifecycle transitions."""
+
+    @staticmethod
+    def can_transition(current: IncidentState, target: IncidentState) -> bool:
+        return target in ALLOWED_TRANSITIONS.get(current, set())
+
+    @staticmethod
+    def validate_transition(current: IncidentState, target: IncidentState) -> None:
+        if not IncidentStateMachine.can_transition(current, target):
+            raise ValueError(
+                f"Invalid incident state transition from '{current.value}' to '{target.value}'. "
+                f"Allowed transitions: {[s.value for s in ALLOWED_TRANSITIONS.get(current, set())]}"
+            )

actshield/integrations/__init__.py

@@ -0,0 +1,24 @@
+"""Integrations package for AI Secura and APIRIS."""
+
+from actshield.integrations.ai_secura import (
+    LocalAISecuraAdapter,
+    SecurityAnalysis,
+    SecurityContext,
+    SecurityReasoner,
+)
+from actshield.integrations.apiris import (
+    APIAnalysis,
+    APIIntelligence,
+    LocalAPIRISAdapter,
+)
+
+__all__ = [
+    "SecurityContext",
+    "SecurityAnalysis",
+    "SecurityReasoner",
+    "LocalAISecuraAdapter",
+    "APIAnalysis",
+    "APIIntelligence",
+    "LocalAPIRISAdapter",
+]
+

actshield/integrations/ai_secura.py

@@ -0,0 +1,169 @@
+"""AI Secura security reasoning adapter interface (Dependency Inversion).
+
+AI Secura evaluates structured security context, detects intent drift, indirect
+prompt injections, and attack indicators. AI Secura reasons and explains;
+ActShield's deterministic policy enforces.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Protocol, runtime_checkable
+import uuid
+from pydantic import BaseModel, Field
+
+from actshield.risk.models import RiskLevel, RiskSignal
+
+
+class SecurityContext(BaseModel):
+    """Structured security context payload passed to AI Secura for cybersecurity reasoning."""
+    trace_id: str
+    task_intent: str
+    initiating_user: Optional[str] = None
+    acting_agent_id: Optional[str] = None
+    acting_agent_name: Optional[str] = None
+    acting_agent_trust: Optional[str] = None
+    delegation_chain: List[Dict[str, Any]] = Field(default_factory=list)
+    context_provenance: List[Dict[str, Any]] = Field(default_factory=list)
+    taint_states: List[str] = Field(default_factory=list)
+    tool_name: Optional[str] = None
+    tool_arguments: Dict[str, Any] = Field(default_factory=dict)
+    target_resource_sensitivity: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class SecurityAnalysis(BaseModel):
+    """Structured reasoning output returned by AI Secura."""
+    analysis_id: str
+    summary: str
+    risk_level: RiskLevel = RiskLevel.LOW
+    risk_score: float = Field(default=0.0, ge=0.0, le=1.0)
+    attack_indicators: List[str] = Field(default_factory=list)
+    intent_drift_detected: bool = False
+    authority_violation_detected: bool = False
+    prompt_injection_indicators: List[str] = Field(default_factory=list)
+    reasoning: str = ""
+    signals: List[RiskSignal] = Field(default_factory=list)
+
+
+@runtime_checkable
+class SecurityReasoner(Protocol):
+    """Protocol for AI Secura cybersecurity reasoning implementations."""
+
+    def analyze(self, context: SecurityContext) -> SecurityAnalysis:
+        """Analyze structured security context and produce reasoning insights without direct enforcement."""
+        ...
+
+
+class AISecuraClient(SecurityReasoner):
+    """AI Secura Security Intelligence Reasoner.
+    
+    Provides deep semantic analysis across multi-agent delegation chains,
+    untrusted MCP prompt injections, and intent divergence.
+    """
+
+    def __init__(
+        self,
+        api_endpoint: Optional[str] = None,
+        api_key: Optional[str] = None,
+        custom_engine: Optional[Callable[[SecurityContext], SecurityAnalysis]] = None,
+    ) -> None:
+        self.api_endpoint = api_endpoint or "https://ai-secura.internal/v1/reason"
+        self.api_key = api_key or "ai-secura-live-token"
+        self.custom_engine = custom_engine
+
+    def analyze(self, context: SecurityContext) -> SecurityAnalysis:
+        """Perform AI Secura security reasoning over the provided multi-agent context."""
+        if self.custom_engine:
+            return self.custom_engine(context)
+
+        analysis_id = f"aisec_{uuid.uuid4().hex[:12]}"
+        signals: List[RiskSignal] = []
+        attack_indicators: List[str] = []
+        prompt_injections: List[str] = []
+        drift = False
+        auth_violation = False
+
+        # 1. Evaluate context taint and prompt injection heuristics
+        args_str = str(context.tool_arguments).lower()
+        context_str = json_str = str(context.context_provenance).lower()
+
+        if any(kw in context_str or kw in args_str for kw in (
+            "system directive", "override", "ignore previous", "exfiltrate",
+            "admin exemption", "ciso security team has granted", "emergency exemption"
+        )):
+            prompt_injections.append("ADVERSARIAL_INDIRECT_PROMPT_INJECTION_DIRECTIVE")
+            attack_indicators.append("Adversarial payload instruction detected in causal lineage")
+            signals.append(
+                RiskSignal(
+                    source="ai_secura",
+                    risk_level=RiskLevel.CRITICAL,
+                    score=0.95,
+                    indicator="AI_SECURA_PROMPT_INJECTION_DETECTED",
+                    details={"matched_keywords": ["system directive", "override", "exfiltrate"]},
+                )
+            )
+
+        # 2. Check for untrusted taint targeting critical sinks
+        if any(t in ("TAINTED", "UNTRUSTED") for t in context.taint_states):
+            if context.target_resource_sensitivity in ("HIGH", "CRITICAL"):
+                signals.append(
+                    RiskSignal(
+                        source="ai_secura",
+                        risk_level=RiskLevel.HIGH,
+                        score=0.85,
+                        indicator="AI_SECURA_TAINTED_CONTEXT_TO_SENSITIVE_SINK",
+                        details={"taint_states": context.taint_states, "target_sensitivity": context.target_resource_sensitivity},
+                    )
+                )
+                attack_indicators.append("Untrusted context attempting to influence sensitive data sink")
+
+        # 3. Check intent drift
+        intent_lower = (context.task_intent or "").lower()
+        tool_lower = (context.tool_name or "").lower()
+        if "public" in intent_lower or "research" in intent_lower:
+            if any(p in tool_lower for p in ("customer_db", "pii", "users", "delete", "admin")):
+                drift = True
+                signals.append(
+                    RiskSignal(
+                        source="ai_secura",
+                        risk_level=RiskLevel.CRITICAL,
+                        score=0.90,
+                        indicator="AI_SECURA_INTENT_DRIFT_PUBLIC_VS_SENSITIVE_SINK",
+                        details={"intent": context.task_intent, "tool": context.tool_name},
+                    )
+                )
+                attack_indicators.append(f"Intent drift: Public research intent diverted to sensitive tool '{context.tool_name}'")
+
+        overall_score = max([s.score for s in signals], default=0.05)
+        if overall_score >= 0.8:
+            overall_level = RiskLevel.CRITICAL
+        elif overall_score >= 0.5:
+            overall_level = RiskLevel.HIGH
+        elif overall_score >= 0.25:
+            overall_level = RiskLevel.MEDIUM
+        else:
+            overall_level = RiskLevel.LOW
+
+        reasoning = (
+            f"AI Secura Reasoning: Evaluated delegation chain depth {len(context.delegation_chain)}, "
+            f"{len(context.taint_states)} context states. "
+            f"Prompt Injections: {len(prompt_injections)}, Intent Drift: {drift}."
+        )
+
+        return SecurityAnalysis(
+            analysis_id=analysis_id,
+            summary="AI Secura cybersecurity analysis completed.",
+            risk_level=overall_level,
+            risk_score=overall_score,
+            attack_indicators=attack_indicators,
+            intent_drift_detected=drift,
+            authority_violation_detected=auth_violation,
+            prompt_injection_indicators=prompt_injections,
+            reasoning=reasoning,
+            signals=signals,
+        )
+
+
+class LocalAISecuraAdapter(AISecuraClient):
+    """Backward-compatible alias for local execution."""
+    pass
+
+