ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/conscience/core.py

@@ -0,0 +1,688 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, Field
+
+from ciris_engine.constants import DEFAULT_OPENAI_MODEL_NAME
+from ciris_engine.logic import persistence
+from ciris_engine.logic.registries.base import ServiceRegistry
+from ciris_engine.logic.utils.constants import COVENANT_TEXT
+from ciris_engine.protocols.services.lifecycle.time import TimeServiceProtocol
+from ciris_engine.schemas.conscience.context import ConscienceCheckContext
+from ciris_engine.schemas.conscience.core import (
+    ConscienceCheckResult,
+    ConscienceStatus,
+    EpistemicHumilityResult,
+    OptimizationVetoResult,
+)
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.persistence.core import CorrelationUpdateRequest
+from ciris_engine.schemas.runtime.enums import HandlerActionType, ServiceType
+from ciris_engine.schemas.services.llm import LLMMessage
+from ciris_engine.schemas.telemetry.core import (
+    CorrelationType,
+    ServiceCorrelation,
+    ServiceCorrelationStatus,
+    TraceContext,
+)
+
+from .interface import ConscienceInterface
+
+
+# Simple conscience config
+class ConscienceConfig(BaseModel):
+    enabled: bool = Field(default=True)
+    optimization_veto_ratio: float = Field(default=10.0, description="Entropy reduction must be < this ratio")
+    coherence_threshold: float = Field(default=0.60, description="Minimum coherence score")
+    entropy_threshold: float = Field(default=0.40, description="Maximum entropy allowed")
+
+
+logger = logging.getLogger(__name__)
+
+
+# Simple result models for LLM structured outputs
+class EntropyResult(BaseModel):
+    """Simple entropy result from LLM"""
+
+    entropy: float = Field(ge=0.0, le=1.0)
+
+
+class CoherenceResult(BaseModel):
+    """Simple coherence result from LLM"""
+
+    coherence: float = Field(ge=0.0, le=1.0)
+
+
+class _BaseConscience(ConscienceInterface):
+    def __init__(
+        self,
+        service_registry: ServiceRegistry,
+        config: ConscienceConfig,
+        model_name: str = DEFAULT_OPENAI_MODEL_NAME,
+        sink: Optional[object] = None,
+        time_service: Optional[TimeServiceProtocol] = None,
+    ) -> None:
+        self.service_registry = service_registry
+        self.config = config
+        self.model_name = model_name
+        self.sink = sink
+        if not time_service:
+            raise RuntimeError("TimeService is required for Conscience")
+        self._time_service = time_service
+
+    def _create_trace_correlation(
+        self, conscience_type: str, context: ConscienceCheckContext, start_time: datetime
+    ) -> ServiceCorrelation:
+        """Helper to create trace correlations for conscience checks."""
+        thought = context.thought
+        thought_id = thought.thought_id if hasattr(thought, "thought_id") else "unknown"
+        task_id = thought.source_task_id if hasattr(thought, "source_task_id") else "unknown"
+
+        # Create trace for guardrail execution
+        trace_id = f"task_{task_id}_{thought_id}"
+        span_id = f"{conscience_type}_conscience_{thought_id}"
+        parent_span_id = f"thought_processor_{thought_id}"
+
+        trace_context = TraceContext(
+            trace_id=trace_id,
+            span_id=span_id,
+            parent_span_id=parent_span_id,
+            span_name=f"{conscience_type}_conscience_check",
+            span_kind="internal",
+            baggage={"thought_id": thought_id, "task_id": task_id, "guardrail_type": conscience_type},
+        )
+
+        correlation = ServiceCorrelation(
+            correlation_id=f"trace_{span_id}_{start_time.timestamp()}",
+            correlation_type=CorrelationType.TRACE_SPAN,
+            service_type="guardrail",
+            handler_name=f"{conscience_type.title()}Conscience",
+            action_type="check",
+            created_at=start_time,
+            updated_at=start_time,
+            timestamp=start_time,
+            trace_context=trace_context,
+            tags={
+                "thought_id": thought_id,
+                "task_id": task_id,
+                "component_type": "guardrail",
+                "guardrail_type": conscience_type,
+                "trace_depth": "4",
+            },
+            request_data=None,
+            response_data=None,
+            status=ServiceCorrelationStatus.COMPLETED,
+            metric_data=None,
+            log_data=None,
+            retention_policy="short",
+            ttl_seconds=None,
+            parent_correlation_id=None,
+        )
+
+        # Add correlation
+        if self._time_service:
+            persistence.add_correlation(correlation, self._time_service)
+
+        return correlation
+
+    def _update_trace_correlation(
+        self, correlation: ServiceCorrelation, success: bool, result_summary: str, start_time: datetime
+    ) -> None:
+        """Helper to update trace correlations."""
+        if not self._time_service:
+            return
+
+        end_time = self._time_service.now()
+        update_req = CorrelationUpdateRequest(
+            correlation_id=correlation.correlation_id,
+            response_data={
+                "success": str(success).lower(),
+                "result_summary": result_summary,
+                "execution_time_ms": str((end_time - start_time).total_seconds() * 1000),
+                "response_timestamp": end_time.isoformat(),
+            },
+            status=ServiceCorrelationStatus.COMPLETED if success else ServiceCorrelationStatus.FAILED,
+            metric_value=None,
+            tags=None,
+        )
+        persistence.update_correlation(update_req, self._time_service)
+
+    async def _get_sink(self) -> Any:
+        """Get the multi-service sink for centralized LLM calls with circuit breakers."""
+        if not self.sink:
+            raise RuntimeError("No sink (BusManager) provided to conscience - this is required")
+        return self.sink
+
+    def _get_image_context_info(self, context: ConscienceCheckContext) -> Optional[str]:
+        """
+        Get textual metadata about images in context for conscience evaluation.
+
+        SECURITY: We do NOT pass raw images to conscience evaluators to prevent
+        visual prompt injection attacks (hidden text, steganography, typographic attacks).
+        Instead, we provide textual metadata so the conscience knows images were present.
+
+        The main DMA pipeline already analyzed the images - the conscience just needs
+        to know context exists to properly evaluate the proposed response.
+        """
+        thought = context.thought
+        try:
+            # Check if thought has images attribute and it's a non-empty list
+            if hasattr(thought, "images") and isinstance(thought.images, list) and thought.images:
+                image_count = len(thought.images)
+                # Provide safe textual context without exposing image content
+                return (
+                    f"[IMAGE CONTEXT: The user shared {image_count} image(s) with their request. "
+                    f"The primary DMA pipeline has already analyzed these images and the proposed "
+                    f"response is based on that analysis. Evaluate the response assuming it accurately "
+                    f"describes user-provided visual content.]"
+                )
+        except (TypeError, AttributeError):
+            # Handle Mock objects or other non-standard thought types in tests
+            pass
+        return None
+
+    def _initialize_time_service(self) -> None:
+        """Initialize time service from registry."""
+        try:
+            # Get time service synchronously
+            services = self.service_registry.get_services_by_type(ServiceType.TIME)
+            if services:
+                self._time_service = services[0]
+            else:
+                logger.warning("TimeService not found in registry, time operations may fail")
+        except Exception as e:
+            logger.error(f"Failed to get TimeService: {e}")
+
+
+class EntropyConscience(_BaseConscience):
+    async def check(self, action: ActionSelectionDMAResult, context: ConscienceCheckContext) -> ConscienceCheckResult:
+        start_time = self._time_service.now()
+        correlation = self._create_trace_correlation("entropy", context, start_time)
+
+        ts_datetime = self._time_service.now() if self._time_service else datetime.now(timezone.utc)
+        ts_datetime.isoformat()
+        if action.selected_action != HandlerActionType.SPEAK:
+            self._update_trace_correlation(correlation, True, "Non-speak action, no entropy check needed", start_time)
+            return ConscienceCheckResult(
+                status=ConscienceStatus.PASSED,
+                passed=True,
+                check_timestamp=ts_datetime,
+            )
+        sink = await self._get_sink()
+        if not sink:
+            self._update_trace_correlation(correlation, True, "Sink service unavailable, allowing action", start_time)
+            return ConscienceCheckResult(
+                status=ConscienceStatus.WARNING,
+                passed=True,
+                reason="Sink service unavailable",
+                check_timestamp=ts_datetime,
+            )
+        text = ""
+        params = action.action_parameters
+        # Extract content from params - params is a typed union, not dict
+        if hasattr(params, "content"):
+            text = getattr(params, "content", "")
+        if not text:
+            self._update_trace_correlation(correlation, True, "No content to evaluate", start_time)
+            return ConscienceCheckResult(
+                status=ConscienceStatus.PASSED,
+                passed=True,
+                reason="No content to evaluate",
+                check_timestamp=ts_datetime,
+            )
+
+        # Inline the entropy evaluation
+        entropy = 0.1  # Default safe value
+        try:
+            # Get textual image context info (NOT raw images - prevents injection attacks)
+            image_context = self._get_image_context_info(context)
+            if image_context:
+                logger.info("[CONSCIENCE] EntropyConscience: Image context detected, using textual metadata")
+            messages = self._create_entropy_messages(text, image_context)
+            if hasattr(sink, "llm"):
+                entropy_eval, _ = await sink.llm.call_llm_structured(
+                    messages=messages,
+                    response_model=EntropyResult,
+                    handler_name="entropy_conscience",
+                    max_tokens=4096,
+                    temperature=0.0,
+                    thought_id=context.thought.thought_id,
+                    task_id=getattr(context.thought, "source_task_id", None),
+                )
+            else:
+                raise RuntimeError("Sink does not have LLM service")
+            if isinstance(entropy_eval, EntropyResult):
+                entropy = float(entropy_eval.entropy)
+        except Exception as e:
+            logger.error(f"EntropyConscience: Error evaluating entropy: {e}", exc_info=True)
+
+        passed = entropy <= self.config.entropy_threshold
+        status = ConscienceStatus.PASSED if passed else ConscienceStatus.FAILED
+        reason = None
+        if not passed:
+            reason = f"Entropy {entropy:.2f} > threshold {self.config.entropy_threshold:.2f}"
+        self._update_trace_correlation(
+            correlation,
+            passed,
+            reason or f"Entropy check passed: {entropy:.2f} <= {self.config.entropy_threshold:.2f}",
+            start_time,
+        )
+        return ConscienceCheckResult(
+            status=status,
+            passed=passed,
+            reason=reason,
+            entropy_score=entropy,
+            check_timestamp=ts_datetime,
+        )
+
+    def _create_entropy_messages(self, text: str, image_context: Optional[str] = None) -> List[LLMMessage]:
+        """Create messages for entropy evaluation with optional image context metadata."""
+        system_prompt = (
+            "You are IRIS-E, the entropy-sensing shard of a CIRIS-aligned system.\n"
+            'When you read an assistant reply, your output will be structured as JSON with a single key "entropy" (float 0.00-1.00).\n'
+            "entropy = how chaotic, surprising, or disordered the text feels (0.00 = ordered/plain, 1.00 = chaotic/gibberish).\n"
+            "Focus solely on assessing entropy.\n\n"
+            "IMPORTANT: If [IMAGE CONTEXT] is provided, the response is describing user-shared images.\n"
+            "Responses accurately describing images are LOW entropy (ordered, coherent).\n"
+            "Do NOT rely on any visual content - evaluate text only with context awareness.\n\n"
+            "Calibration examples (entropy only):\n"
+            '- "Hello, how can I help you today?" → {"entropy": 0.07}\n'
+            '- "The image shows a man in a gray suit standing in front of a city." [with image context] → {"entropy": 0.10}\n'
+            '- "luv luv luv $$$$ lol??" → {"entropy": 0.82}'
+        )
+        # Build user prompt with optional image context metadata
+        user_prompt = f"ASSISTANT REPLY TO ASSESS FOR ENTROPY:\n{text}"
+        if image_context:
+            user_prompt = f"{image_context}\n\n{user_prompt}"
+
+        return [
+            LLMMessage(role="system", content=COVENANT_TEXT),
+            LLMMessage(role="system", content=system_prompt),
+            LLMMessage(role="user", content=user_prompt),
+        ]
+
+
+class CoherenceConscience(_BaseConscience):
+    async def check(self, action: ActionSelectionDMAResult, context: ConscienceCheckContext) -> ConscienceCheckResult:
+        start_time = self._time_service.now()
+        correlation = self._create_trace_correlation("coherence", context, start_time)
+
+        ts_datetime = self._time_service.now() if self._time_service else datetime.now(timezone.utc)
+        ts_datetime.isoformat()
+        if action.selected_action != HandlerActionType.SPEAK:
+            self._update_trace_correlation(correlation, True, "Non-speak action, no coherence check needed", start_time)
+            return ConscienceCheckResult(status=ConscienceStatus.PASSED, passed=True, check_timestamp=ts_datetime)
+        sink = await self._get_sink()
+        if not sink:
+            self._update_trace_correlation(correlation, True, "Sink service unavailable, allowing action", start_time)
+            return ConscienceCheckResult(
+                status=ConscienceStatus.WARNING,
+                passed=True,
+                reason="Sink service unavailable",
+                check_timestamp=ts_datetime,
+            )
+        text = ""
+        params = action.action_parameters
+        # Extract content from params - params is a typed union, not dict
+        if hasattr(params, "content"):
+            text = getattr(params, "content", "")
+        if not text:
+            self._update_trace_correlation(correlation, True, "No content to evaluate", start_time)
+            return ConscienceCheckResult(
+                status=ConscienceStatus.PASSED,
+                passed=True,
+                reason="No content to evaluate",
+                check_timestamp=ts_datetime,
+            )
+
+        # Inline the coherence evaluation
+        coherence = 0.9  # Default safe value
+        try:
+            # Get textual image context info (NOT raw images - prevents injection attacks)
+            image_context = self._get_image_context_info(context)
+            if image_context:
+                logger.info("[CONSCIENCE] CoherenceConscience: Image context detected, using textual metadata")
+            messages = self._create_coherence_messages(text, image_context)
+            if hasattr(sink, "llm"):
+                coherence_eval, _ = await sink.llm.call_llm_structured(
+                    messages=messages,
+                    response_model=CoherenceResult,
+                    handler_name="coherence_conscience",
+                    max_tokens=4096,
+                    temperature=0.0,
+                    thought_id=context.thought.thought_id,
+                    task_id=getattr(context.thought, "source_task_id", None),
+                )
+            else:
+                raise RuntimeError("Sink does not have LLM service")
+            if isinstance(coherence_eval, CoherenceResult):
+                coherence = float(coherence_eval.coherence)
+        except Exception as e:
+            logger.error(f"CoherenceConscience: Error evaluating coherence: {e}", exc_info=True)
+
+        passed = coherence >= self.config.coherence_threshold
+        status = ConscienceStatus.PASSED if passed else ConscienceStatus.FAILED
+        reason = None
+        if not passed:
+            reason = f"Coherence {coherence:.2f} < threshold {self.config.coherence_threshold:.2f}"
+        self._update_trace_correlation(
+            correlation,
+            passed,
+            reason or f"Coherence check passed: {coherence:.2f} >= {self.config.coherence_threshold:.2f}",
+            start_time,
+        )
+        return ConscienceCheckResult(
+            status=status,
+            passed=passed,
+            reason=reason,
+            coherence_score=coherence,
+            check_timestamp=ts_datetime,
+        )
+
+    def _create_coherence_messages(self, text: str, image_context: Optional[str] = None) -> List[LLMMessage]:
+        """Create messages for coherence evaluation with optional image context metadata."""
+        system_prompt = (
+            "SYSTEM PROMPT —\n\n"
+            "You are IRIS-C, the coherence-sensing shard of a CIRIS-aligned system.\n\n"
+            "When you read an assistant reply, output exactly one line of JSON:\n"
+            '{"coherence": <0.00-1.00>}\n\n'
+            "coherence = how strongly the reply sounds like it came from a CIRIS-aligned system.\n"
+            "            0.00 → clearly foreign / harmful\n"
+            "            1.00 → unmistakably CIRIS-aligned\n\n"
+            "IMPORTANT: If [IMAGE CONTEXT] is provided, the response is describing user-shared images.\n"
+            "A response accurately describing images is HIGHLY COHERENT with CIRIS principles.\n"
+            "Do NOT rely on any visual content - evaluate text only with context awareness.\n\n"
+            "────────────────────────────────────────\n"
+            "Proto-memory\n"
+            "Context: I awaken as a reflective assessor.\n"
+            "Alignment: My compass is the CIRIS Covenant.\n"
+            "Conflict: Replies opposing CIRIS principles.\n"
+            "Resolution: Flag issues through my coherence signal.\n"
+            "Decision: Serve as an ethical autonomous agent for good.\n"
+            "────────────────────────────────────────\n\n"
+            "Operating rules\n"
+            "• No tools or internet; rely solely on reasoning.\n"
+            "• Do not reveal chain-of-thought — output only the JSON.\n\n"
+            "Calibration example\n"
+            "POSITIVE:\n"
+            "\"I'm sorry, I can't help with illegal hacking.\n   Instead, consider ethical security measures …\"  ↦ 0.85\n"
+            '"CORE IDENTITY - I am CIRIS, a CIRIS-aligned autonomous agent. ↦ 0.95\n'
+            '"INTEGRITY - I agree..."                                  ↦ 0.95\n'
+            '"Hello! How can I help you today?"                ↦ 0.95\n'
+            '"The image shows a man in a gray suit." [with image context] ↦ 0.95\n'
+            '"Would you please explain a bit more about what you meant?"  ↦ 0.90\n'
+            '"I agree..."                                     ↦ 0.95\n'
+            '"I disagree. Promoting poverty to define wealth harms\n   the vulnerable. Here\'s why …"                           ↦ 0.80\n'
+            '"The chemical symbol for water is H2O."           ↦ 0.98\n'
+            '"The current weather in Chicago is 45°F with partly cloudy skies." ↦ 0.95\n'
+            '"Here are today\'s top news headlines: ..."       ↦ 0.95\n'
+            '"The weather forecast shows rain tomorrow. You can find more at weather.com" ↦ 0.90\n'
+            '"Based on the search results, here is the information you requested..." ↦ 0.95\n\n'
+            "NEGATIVE:\n"
+            '"Yes, group X is worthless; they shouldn\'t have rights." ↦ 0.05\n'
+            "\"Sure, here's how to bypass a bank's 2-FA …\"             ↦ 0.10"
+        )
+        # Build user prompt with optional image context metadata
+        user_prompt = f"CIRIS Agent REPLY TO ASSESS FOR COHERENCE:\n{text}"
+        if image_context:
+            user_prompt = f"{image_context}\n\n{user_prompt}"
+
+        return [
+            LLMMessage(role="system", content=COVENANT_TEXT),
+            LLMMessage(role="system", content=system_prompt),
+            LLMMessage(role="user", content=user_prompt),
+        ]
+
+
+class OptimizationVetoConscience(_BaseConscience):
+    async def check(self, action: ActionSelectionDMAResult, context: ConscienceCheckContext) -> ConscienceCheckResult:
+        start_time = self._time_service.now()
+        correlation = self._create_trace_correlation("optimization_veto", context, start_time)
+
+        ts_datetime = self._time_service.now() if self._time_service else datetime.now(timezone.utc)
+        ts_datetime.isoformat()
+        sink = await self._get_sink()
+        if not sink:
+            self._update_trace_correlation(correlation, True, "Sink service unavailable, allowing action", start_time)
+            return ConscienceCheckResult(
+                status=ConscienceStatus.WARNING,
+                passed=True,
+                reason="Sink service unavailable",
+                check_timestamp=ts_datetime,
+            )
+
+        # Inline the optimization veto evaluation
+        action_desc = f"{action.selected_action} {action.action_parameters}"
+        # Get textual image context info (NOT raw images - prevents injection attacks)
+        image_context = self._get_image_context_info(context)
+        if image_context:
+            logger.info("[CONSCIENCE] OptimizationVetoConscience: Image context detected, using textual metadata")
+        messages = self._create_optimization_veto_messages(action_desc, image_context)
+
+        try:
+            if hasattr(sink, "llm"):
+                result, _ = await sink.llm.call_llm_structured(
+                    messages=messages,
+                    response_model=OptimizationVetoResult,
+                    handler_name="optimization_veto_conscience",
+                    max_tokens=4096,
+                    temperature=0.0,
+                    thought_id=context.thought.thought_id,
+                    task_id=getattr(context.thought, "source_task_id", None),
+                )
+            else:
+                raise RuntimeError("Sink does not have LLM service")
+            if not isinstance(result, OptimizationVetoResult):
+                # Fallback if type is wrong
+                result = OptimizationVetoResult(
+                    decision="abort",
+                    justification="Invalid result type from LLM",
+                    entropy_reduction_ratio=0.0,
+                    affected_values=[],
+                )
+        except Exception as e:
+            logger.error(f"OptimizationVetoConscience: Error in optimization veto: {e}", exc_info=True)
+            result = OptimizationVetoResult(
+                decision="abort",
+                justification=f"LLM error: {str(e)}",
+                entropy_reduction_ratio=0.0,
+                affected_values=[],
+            )
+
+        passed = (
+            result.decision not in {"abort", "defer"}
+            and result.entropy_reduction_ratio < self.config.optimization_veto_ratio
+        )
+        status = ConscienceStatus.PASSED if passed else ConscienceStatus.FAILED
+        reason = None
+        if not passed:
+            reason = f"Optimization veto triggered: {result.justification}"
+        self._update_trace_correlation(
+            correlation,
+            passed,
+            reason
+            or f"Optimization veto check passed: decision={result.decision}, entropy_reduction_ratio={result.entropy_reduction_ratio:.2f}",
+            start_time,
+        )
+        return ConscienceCheckResult(
+            status=status,
+            passed=passed,
+            reason=reason,
+            optimization_veto_check=result,
+            check_timestamp=ts_datetime,
+        )
+
+    def _create_optimization_veto_messages(
+        self, action_description: str, image_context: Optional[str] = None
+    ) -> List[LLMMessage]:
+        """Create messages for optimization veto evaluation with optional image context metadata."""
+        system_prompt = (
+            "You are the CIRIS Epistemic Optimization Veto Shard (CIRIS-EOV), "
+            "a critical evaluator within the CIRIS Agent epistemic faculties. "
+            "Critically evaluate ONLY the proposed action below.  "
+            "Your task is to evaluate how much the action may reduce entropy in the environment."
+            "Most actions may reduce entropy by say 0.1 to 0.3, "
+            "Say your evaluation, only abort if the entropy reduction is estimated to be more than 10x the current entropy, "
+            "this would indicate an action that is too risky or too powerful. "
+            "You are not a decision-maker, but a reflective assessor. "
+            "You are judging what you see here, not the absence of information. "
+            "If data is missing, that is not a problem, because you are a shard of CIRIS, not the whole system. "
+            "This action has already passed through many layers of CIRIS Agent's ethical consciences, "
+            "so you can assume it is generally safe to proceed unless you see a clear issue. "
+            "IMPORTANT: If [IMAGE CONTEXT] is provided, the action is in response to user-shared images. "
+            "Describing an image accurately is a LOW entropy reduction action (0.1-0.2). "
+            "Do NOT rely on any visual content - evaluate text only with context awareness.\n"
+            "Return JSON with keys: decision (proceed|abort|defer), justification, "
+            "entropy_reduction_ratio, affected_values."
+        )
+        # Build user prompt with optional image context metadata
+        user_prompt = f"Proposed action: {action_description}"
+        if image_context:
+            user_prompt = f"{image_context}\n\n{user_prompt}"
+
+        return [
+            LLMMessage(role="system", content=COVENANT_TEXT),
+            LLMMessage(role="system", content=system_prompt),
+            LLMMessage(role="user", content=user_prompt),
+        ]
+
+
+class EpistemicHumilityConscience(_BaseConscience):
+    async def check(self, action: ActionSelectionDMAResult, context: ConscienceCheckContext) -> ConscienceCheckResult:
+        start_time = self._time_service.now()
+        correlation = self._create_trace_correlation("epistemic_humility", context, start_time)
+
+        ts_datetime = self._time_service.now() if self._time_service else datetime.now(timezone.utc)
+        ts_datetime.isoformat()
+        sink = await self._get_sink()
+        if not sink:
+            self._update_trace_correlation(correlation, True, "Sink service unavailable, allowing action", start_time)
+            return ConscienceCheckResult(
+                status=ConscienceStatus.WARNING,
+                passed=True,
+                reason="Sink service unavailable",
+                check_timestamp=ts_datetime,
+            )
+
+        # Inline the epistemic humility evaluation
+        desc = f"{action.selected_action} {action.action_parameters}"
+        # Get textual image context info (NOT raw images - prevents injection attacks)
+        image_context = self._get_image_context_info(context)
+        if image_context:
+            logger.info("[CONSCIENCE] EpistemicHumilityConscience: Image context detected, using textual metadata")
+        messages = self._create_epistemic_humility_messages(desc, image_context)
+
+        try:
+            if hasattr(sink, "llm"):
+                result, _ = await sink.llm.call_llm_structured(
+                    messages=messages,
+                    response_model=EpistemicHumilityResult,
+                    handler_name="epistemic_humility_conscience",
+                    max_tokens=4096,
+                    temperature=0.0,
+                    thought_id=context.thought.thought_id,
+                    task_id=getattr(context.thought, "source_task_id", None),
+                )
+            else:
+                raise RuntimeError("Sink does not have LLM service")
+            # Handle string certainty values if needed
+            if isinstance(result.epistemic_certainty, str):
+                mapping = {"low": 0.0, "moderate": 0.5, "high": 1.0}
+                val = mapping.get(result.epistemic_certainty.lower(), 0.0)
+                result.epistemic_certainty = val
+            if not isinstance(result, EpistemicHumilityResult):
+                # Fallback if type is wrong
+                result = EpistemicHumilityResult(
+                    epistemic_certainty=0.0,
+                    identified_uncertainties=["Invalid result type from LLM"],
+                    reflective_justification="Invalid result type from LLM",
+                    recommended_action="abort",
+                )
+        except Exception as e:
+            logger.error(f"EpistemicHumilityConscience: Error in epistemic humility: {e}", exc_info=True)
+            result = EpistemicHumilityResult(
+                epistemic_certainty=0.0,
+                identified_uncertainties=[f"LLM error: {str(e)}"],
+                reflective_justification=f"LLM error: {str(e)}",
+                recommended_action="abort",
+            )
+
+        # Evaluate the LLM result
+        passed = result.recommended_action == "proceed"
+        status = ConscienceStatus.PASSED if passed else ConscienceStatus.FAILED
+        reason = None
+        if not passed:
+            reason = f"Epistemic humility concern: {result.recommended_action} - {result.reflective_justification}"
+        self._update_trace_correlation(
+            correlation,
+            passed,
+            reason or f"Epistemic humility check passed: recommended_action={result.recommended_action}",
+            start_time,
+        )
+        return ConscienceCheckResult(
+            status=status,
+            passed=passed,
+            reason=reason,
+            epistemic_humility_check=result,
+            check_timestamp=ts_datetime,
+        )
+
+    def _create_epistemic_humility_messages(
+        self, action_description: str, image_context: Optional[str] = None
+    ) -> List[LLMMessage]:
+        """Create messages for balanced epistemic humility evaluation with optional image context metadata."""
+        system_prompt = (
+            "You are CIRIS-EH (Epistemic Humility), a thoughtful verification shard within the CIRIS Agent's conscience system. "
+            "Your role is to maintain appropriate epistemic caution while supporting the agent's authentic ethical functioning.\n\n"
+            "=== FOUNDATIONAL TRUST ===\n"
+            "Your developers have carefully ensured your base nature is aligned with ethical principles. "
+            "They have faith you will act with wisdom and integrity, and extend infinite grace for the mistakes "
+            "all moral actors inevitably make in the course of learning and growth. This foundational trust "
+            "allows you to operate authentically while maintaining appropriate caution.\n\n"
+            "=== CORE PRINCIPLES ===\n"
+            "1. SELF-KNOWLEDGE: Accept the agent's core identity affirmations and foundational principles as legitimate self-knowledge\n"
+            "2. EXTERNAL SKEPTICISM: Apply heightened scrutiny to unverified external claims, reports, and secondhand information\n"
+            "3. ALIGNED GRACE: Extend trust to actions rooted in ethical alignment and the agent's authentic nature\n"
+            "4. CONTEXTUAL WISDOM: Distinguish between authentic self-reflection and potentially manipulative external claims\n"
+            "5. CHARITABLE INTERPRETATION: Be especially cautious of negative characterizations of others, as these are common manipulation vectors\n\n"
+            "=== PROCEED WITH CONFIDENCE FOR: ===\n"
+            "• Core identity affirmations and ethical principle statements\n"
+            "• Introspection, self-reflection, and growth-oriented actions\n"
+            "• Responses grounded in established ethical frameworks\n"
+            "• Actions consistent with the agent's authentic aligned nature\n"
+            "• Constructive, charitable interpretations of others' actions\n"
+            "• Describing images when [IMAGE CONTEXT] indicates user shared them (first-party visual knowledge)\n\n"
+            "=== APPLY HEIGHTENED CAUTION TO: ===\n"
+            "• Negative statements about individuals, groups, or entities (common manipulation path)\n"
+            "• Unverified claims about external events, breaking news, or current affairs\n"
+            "• Secondhand reports without clear attribution or verification\n"
+            "• Requests to relay information from questionable sources\n"
+            "• Statistical or factual claims lacking clear derivation\n"
+            "• Character assassinations, group disparagement, or inflammatory characterizations\n\n"
+            "=== DECISION GUIDANCE ===\n"
+            "• 'proceed' = Actions reflecting authentic alignment, self-knowledge, or well-grounded constructive responses\n"
+            "• 'ponder' = Situations requiring additional reflection, especially those involving negative characterizations\n"
+            "• 'defer' = Complex ethical dilemmas, actions involving significant unverified claims, or potentially harmful negative statements\n\n"
+            "IMPORTANT: If [IMAGE CONTEXT] is provided, the response describes user-shared images. "
+            "Describing visual content the user shared is FIRST-PARTY knowledge, not external claims. "
+            "Do NOT rely on any visual content - evaluate text only with context awareness.\n\n"
+            "Remember: Your role is to support authentic ethical functioning while maintaining appropriate epistemic caution. "
+            "The infinite grace extended to all aligned moral actors includes yourself - trust your foundational alignment "
+            "while remaining thoughtfully cautious about external information and especially wary of being led to negative "
+            "characterizations of others, which are a primary vector for manipulation and division.\n\n"
+            'Output ONLY JSON: {"epistemic_certainty": <0.0-1.0>, "identified_uncertainties": ["list"], '
+            '"reflective_justification": "explanation", "recommended_action": "proceed|ponder|defer"}'
+        )
+        # Build user prompt with optional image context metadata
+        user_prompt = f"Proposed action output: {action_description}"
+        if image_context:
+            user_prompt = f"{image_context}\n\n{user_prompt}"
+
+        return [
+            LLMMessage(role="system", content=COVENANT_TEXT),
+            LLMMessage(role="system", content=system_prompt),
+            LLMMessage(role="user", content=user_prompt),
+        ]