ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/schemas/config/default_dsar_sops.py

@@ -0,0 +1,178 @@
+"""
+Default DSAR ticket SOPs - present in ALL agent templates for GDPR compliance.
+
+These SOPs are automatically added to every agent's ticket configuration.
+"""
+
+from ciris_engine.schemas.config.tickets import TicketSOPConfig, TicketStageConfig
+
+# Stage descriptions used across multiple DSAR SOPs
+STAGE_DESC_IDENTITY_RESOLUTION = "Resolve user identity across all data sources"
+
+# GDPR Article 15 - Right of Access
+DSAR_ACCESS_SOP = TicketSOPConfig(
+    sop="DSAR_ACCESS",
+    ticket_type="dsar",
+    required_fields=["email", "user_identifier"],
+    deadline_days=30,  # GDPR 30-day compliance requirement
+    priority_default=8,
+    description="GDPR Article 15 - Data Subject Access Request for user data export",
+    stages=[
+        TicketStageConfig(
+            name="identity_resolution",
+            tools=["identity_resolution_tool"],
+            description=STAGE_DESC_IDENTITY_RESOLUTION,
+        ),
+        TicketStageConfig(
+            name="ciris_data_collection",
+            tools=["dsar_automation_access"],
+            optional=True,  # User may not exist in CIRIS
+            description="Collect user data from CIRIS internal storage",
+        ),
+        TicketStageConfig(
+            name="external_data_collection",
+            tools=["sql_find_user_data", "sql_export_user"],
+            parallel=True,
+            optional=True,  # May not have external data sources
+            description="Collect user data from external SQL databases",
+        ),
+        TicketStageConfig(
+            name="data_packaging",
+            tools=["package_dsar_response"],
+            description="Package all collected data for user delivery",
+        ),
+        TicketStageConfig(
+            name="delivery",
+            tools=["send_email"],
+            description="Deliver DSAR package to user email",
+        ),
+    ],
+)
+
+# GDPR Article 17 - Right to Erasure
+DSAR_DELETE_SOP = TicketSOPConfig(
+    sop="DSAR_DELETE",
+    ticket_type="dsar",
+    required_fields=["email", "user_identifier"],
+    deadline_days=30,  # GDPR 30-day compliance requirement
+    priority_default=9,  # Higher priority - data deletion
+    description="GDPR Article 17 - Right to Erasure (Right to be Forgotten)",
+    stages=[
+        TicketStageConfig(
+            name="identity_resolution",
+            tools=["identity_resolution_tool"],
+            description=STAGE_DESC_IDENTITY_RESOLUTION,
+        ),
+        TicketStageConfig(
+            name="deletion_verification",
+            tools=["verify_deletion_eligibility"],
+            description="Verify user can be deleted (no legal holds, etc.)",
+        ),
+        TicketStageConfig(
+            name="ciris_data_deletion",
+            tools=["dsar_automation_delete"],
+            optional=True,
+            description="Delete user data from CIRIS internal storage",
+        ),
+        TicketStageConfig(
+            name="external_data_deletion",
+            tools=["sql_delete_user"],
+            parallel=True,
+            optional=True,
+            description="Delete user data from external SQL databases",
+        ),
+        TicketStageConfig(
+            name="deletion_confirmation",
+            tools=["send_email"],
+            description="Send deletion confirmation to user",
+        ),
+    ],
+)
+
+# GDPR Article 20 - Right to Data Portability
+DSAR_EXPORT_SOP = TicketSOPConfig(
+    sop="DSAR_EXPORT",
+    ticket_type="dsar",
+    required_fields=["email", "user_identifier"],
+    deadline_days=30,
+    priority_default=7,
+    description="GDPR Article 20 - Right to Data Portability (machine-readable export)",
+    stages=[
+        TicketStageConfig(
+            name="identity_resolution",
+            tools=["identity_resolution_tool"],
+            description=STAGE_DESC_IDENTITY_RESOLUTION,
+        ),
+        TicketStageConfig(
+            name="ciris_data_export",
+            tools=["dsar_automation_export"],
+            optional=True,
+            description="Export user data from CIRIS in machine-readable format",
+        ),
+        TicketStageConfig(
+            name="external_data_export",
+            tools=["sql_export_user"],
+            parallel=True,
+            optional=True,
+            description="Export user data from external SQL databases",
+        ),
+        TicketStageConfig(
+            name="format_conversion",
+            tools=["convert_to_portable_format"],
+            description="Convert all data to portable format (JSON/CSV)",
+        ),
+        TicketStageConfig(
+            name="delivery",
+            tools=["send_email"],
+            description="Deliver portable data package to user",
+        ),
+    ],
+)
+
+# GDPR Article 16 - Right to Rectification
+DSAR_RECTIFY_SOP = TicketSOPConfig(
+    sop="DSAR_RECTIFY",
+    ticket_type="dsar",
+    required_fields=["email", "user_identifier", "correction_details"],
+    deadline_days=30,
+    priority_default=7,
+    description="GDPR Article 16 - Right to Rectification (correct inaccurate data)",
+    stages=[
+        TicketStageConfig(
+            name="identity_resolution",
+            tools=["identity_resolution_tool"],
+            description=STAGE_DESC_IDENTITY_RESOLUTION,
+        ),
+        TicketStageConfig(
+            name="data_verification",
+            tools=["verify_current_data"],
+            description="Retrieve current user data for verification",
+        ),
+        TicketStageConfig(
+            name="ciris_data_correction",
+            tools=["update_user_data"],
+            optional=True,
+            description="Apply corrections to CIRIS internal storage",
+        ),
+        TicketStageConfig(
+            name="external_data_correction",
+            tools=["sql_update_user"],
+            parallel=True,
+            optional=True,
+            description="Apply corrections to external SQL databases",
+        ),
+        TicketStageConfig(
+            name="correction_confirmation",
+            tools=["send_email"],
+            description="Send correction confirmation to user",
+        ),
+    ],
+)
+
+# Default DSAR SOPs that ALL agents get
+DEFAULT_DSAR_SOPS = [
+    DSAR_ACCESS_SOP,
+    DSAR_DELETE_SOP,
+    DSAR_EXPORT_SOP,
+    DSAR_RECTIFY_SOP,
+]

ciris_engine/schemas/config/essential.py

@@ -0,0 +1,195 @@
+"""
+Essential Configuration Schema for CIRIS Bootstrap.
+
+Mission-critical configuration only. No ambiguity allowed.
+This replaces AppConfig for a cleaner, graph-based config system.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+def _get_default_main_db() -> Path:
+    """Get default main database path using central path resolution."""
+    from ciris_engine.logic.utils.path_resolution import get_data_dir
+
+    return get_data_dir() / "ciris_engine.db"
+
+
+def _get_default_secrets_db() -> Path:
+    """Get default secrets database path using central path resolution."""
+    from ciris_engine.logic.utils.path_resolution import get_data_dir
+
+    return get_data_dir() / "secrets.db"
+
+
+def _get_default_audit_db() -> Path:
+    """Get default audit database path using central path resolution."""
+    from ciris_engine.logic.utils.path_resolution import get_data_dir
+
+    return get_data_dir() / "ciris_audit.db"
+
+
+class DatabaseConfig(BaseModel):
+    """Core database paths configuration."""
+
+    main_db: Path = Field(default_factory=_get_default_main_db, description="Main SQLite database for persistence")
+    secrets_db: Path = Field(default_factory=_get_default_secrets_db, description="Encrypted secrets storage database")
+    audit_db: Path = Field(default_factory=_get_default_audit_db, description="Audit trail database with signatures")
+    database_url: Optional[str] = Field(
+        None,
+        description="Database connection string. If set, overrides main_db path. "
+        "Format: 'sqlite://path/to/db' or 'postgresql://user:pass@host:port/dbname'. "
+        "Defaults to SQLite at main_db path for backward compatibility.",
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ServiceEndpointsConfig(BaseModel):
+    """External service endpoints configuration."""
+
+    llm_endpoint: str = Field("https://api.openai.com/v1", description="LLM API endpoint URL")
+    llm_model: str = Field("gpt-4o-mini", description="LLM model identifier")
+    llm_timeout: int = Field(30, description="LLM request timeout in seconds")
+    llm_max_retries: int = Field(3, description="Maximum LLM retry attempts")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SecurityConfig(BaseModel):
+    """Security and audit configuration."""
+
+    audit_retention_days: int = Field(90, description="Days to retain audit logs")
+    secrets_encryption_key_env: str = Field(
+        "CIRIS_MASTER_KEY", description="Environment variable containing master encryption key"
+    )
+    secrets_key_path: Path = Field(Path(".ciris_keys"), description="Directory containing secrets master key")
+    audit_key_path: Path = Field(Path("audit_keys"), description="Directory containing audit signing keys")
+    enable_signed_audit: bool = Field(True, description="Enable cryptographic signing of audit entries")
+    max_thought_depth: int = Field(7, description="Maximum thought chain depth before auto-defer")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class OperationalLimitsConfig(BaseModel):
+    """Operational limits and thresholds."""
+
+    max_active_tasks: int = Field(10, description="Maximum concurrent active tasks")
+    max_active_thoughts: int = Field(50, description="Maximum thoughts in processing queue")
+    round_delay_seconds: float = Field(5.0, description="Delay between processing rounds")
+    mock_llm_round_delay: float = Field(0.1, description="Reduced delay for mock LLM testing")
+    dma_retry_limit: int = Field(3, description="Maximum DMA evaluation retries")
+    dma_timeout_seconds: float = Field(30.0, description="DMA evaluation timeout")
+    conscience_retry_limit: int = Field(2, description="Maximum conscience evaluation retries")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TelemetryConfig(BaseModel):
+    """Telemetry configuration."""
+
+    enabled: bool = Field(False, description="Enable telemetry collection")
+    export_interval_seconds: int = Field(60, description="Telemetry export interval")
+    retention_hours: int = Field(24, description="Telemetry data retention period")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class WorkflowConfig(BaseModel):
+    """Workflow configuration for agent processing."""
+
+    max_rounds: int = Field(10, description="Maximum rounds of processing before automatic pause")
+    round_timeout_seconds: float = Field(300.0, description="Timeout for each processing round")
+    enable_auto_defer: bool = Field(True, description="Automatically defer when hitting limits")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class GraphConfig(BaseModel):
+    """Graph service configuration."""
+
+    # TSDB Consolidation settings
+    # Note: Consolidation intervals are FIXED for calendar alignment:
+    # - Basic: Every 6 hours (00:00, 06:00, 12:00, 18:00 UTC)
+    # - Extensive: Every Monday at 00:00 UTC
+    # - Profound: 1st of each month at 00:00 UTC
+
+    tsdb_profound_target_mb_per_day: float = Field(
+        20.0, description="Target size in MB per day after profound consolidation"
+    )
+    tsdb_raw_retention_hours: int = Field(24, description="How long to keep raw TSDB data before basic consolidation")
+    consolidation_timezone: str = Field("UTC", description="Timezone for consolidation scheduling (default: UTC)")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class EssentialConfig(BaseModel):
+    """
+    Mission-critical configuration for CIRIS bootstrap.
+
+    This is the minimal configuration needed to start core services.
+    After bootstrap, all config is migrated to GraphConfigService.
+    """
+
+    database: DatabaseConfig = Field(default_factory=lambda: DatabaseConfig())
+    services: ServiceEndpointsConfig = Field(default_factory=lambda: ServiceEndpointsConfig())
+    security: SecurityConfig = Field(default_factory=lambda: SecurityConfig())
+    limits: OperationalLimitsConfig = Field(default_factory=lambda: OperationalLimitsConfig())
+    telemetry: TelemetryConfig = Field(default_factory=lambda: TelemetryConfig())
+    workflow: WorkflowConfig = Field(default_factory=lambda: WorkflowConfig())
+    graph: GraphConfig = Field(default_factory=lambda: GraphConfig())
+
+    # Runtime settings
+    log_level: str = Field("INFO", description="Logging level")
+    debug_mode: bool = Field(False, description="Enable debug mode")
+    template_directory: Path = Field(Path("ciris_templates"), description="Directory containing identity templates")
+    default_template: str = Field("default", description="Default template name for agent identity creation")
+    agent_occurrence_id: str = Field(
+        "default",
+        description="Unique ID for this runtime occurrence (enables multiple instances against same database)",
+    )
+
+    model_config = ConfigDict(extra="forbid")  # No ambiguity allowed in mission-critical config
+
+    def load_env_vars(self) -> None:
+        """Load configuration from environment variables if present."""
+        import os
+
+        # Check both CIRIS_OCCURRENCE_ID (new standard) and AGENT_OCCURRENCE_ID (legacy) for backward compatibility
+        env_occurrence_id = os.getenv("CIRIS_OCCURRENCE_ID") or os.getenv("AGENT_OCCURRENCE_ID")
+        if env_occurrence_id:
+            self.agent_occurrence_id = env_occurrence_id
+
+        # Load database URL from environment (supports PostgreSQL with credentials)
+        env_db_url = os.getenv("CIRIS_DB_URL")
+        if env_db_url:
+            self.database.database_url = env_db_url
+
+        # Load template from environment (set by setup wizard)
+        env_template = os.getenv("CIRIS_TEMPLATE")
+        if env_template:
+            self.default_template = env_template
+
+
+class CIRISNodeConfig(BaseModel):
+    """Configuration for CIRISNode integration."""
+
+    base_url: Optional[str] = Field(None, description="CIRISNode base URL")
+    enabled: bool = Field(False, description="Whether CIRISNode integration is enabled")
+
+    model_config = ConfigDict(extra="forbid")
+
+    def load_env_vars(self) -> None:
+        """Load configuration from environment variables if present."""
+        from ciris_engine.logic.config.env_utils import get_env_var
+
+        env_url = get_env_var("CIRISNODE_BASE_URL")
+        if env_url:
+            self.base_url = env_url
+
+        env_enabled = get_env_var("CIRISNODE_ENABLED")
+        if env_enabled is not None:
+            self.enabled = env_enabled.lower() in ("true", "1", "yes", "on")

ciris_engine/schemas/config/tickets.py

@@ -0,0 +1,86 @@
+"""
+Ticket configuration schemas for agent templates.
+
+Tickets are CIRIS's mechanism for tracking multi-stage workflows with SOP (Standard Operating Procedure) enforcement.
+DSAR tickets are always present (GDPR compliance), agents can add custom ticket types via templates.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class TicketStageConfig(BaseModel):
+    """Configuration for a single stage in a ticket workflow."""
+
+    name: str = Field(..., description="Stage name (e.g., 'identity_resolution', 'data_export')")
+    tools: List[str] = Field(default_factory=list, description="List of tool names required for this stage")
+    optional: bool = Field(
+        default=False,
+        description="Whether this stage is optional (failure won't block ticket completion)",
+    )
+    parallel: bool = Field(
+        default=False,
+        description="Whether tools in this stage can be executed in parallel",
+    )
+    description: Optional[str] = Field(
+        None,
+        description="Human-readable description of what this stage does",
+    )
+
+
+class TicketSOPConfig(BaseModel):
+    """Configuration for a Standard Operating Procedure (SOP)."""
+
+    sop: str = Field(..., description="SOP identifier (e.g., 'DSAR_ACCESS', 'APPOINTMENT_SCHEDULE')")
+    ticket_type: str = Field(..., description="Ticket type category (e.g., 'dsar', 'appointment', 'incident')")
+    required_fields: List[str] = Field(
+        default_factory=list,
+        description="List of required metadata fields for ticket creation",
+    )
+    deadline_days: Optional[int] = Field(
+        None,
+        description="Number of days until deadline (e.g., 30 for GDPR compliance)",
+    )
+    priority_default: int = Field(
+        default=5,
+        ge=1,
+        le=10,
+        description="Default priority level (1=lowest, 10=urgent)",
+    )
+    stages: List[TicketStageConfig] = Field(
+        default_factory=list,
+        description="Ordered list of stages in the ticket workflow",
+    )
+    description: Optional[str] = Field(
+        None,
+        description="Human-readable description of what this SOP does",
+    )
+
+
+class TicketsConfig(BaseModel):
+    """Ticket system configuration for an agent."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Whether ticket system is enabled for this agent (DSAR always present)",
+    )
+    sops: List[TicketSOPConfig] = Field(
+        default_factory=list,
+        description="List of supported Standard Operating Procedures",
+    )
+
+    def get_sop(self, sop_name: str) -> Optional[TicketSOPConfig]:
+        """Get SOP configuration by name."""
+        for sop in self.sops:
+            if sop.sop == sop_name:
+                return sop
+        return None
+
+    def is_sop_supported(self, sop_name: str) -> bool:
+        """Check if an SOP is supported."""
+        return any(sop.sop == sop_name for sop in self.sops)
+
+    def list_sops(self) -> List[str]:
+        """List all supported SOP names."""
+        return [sop.sop for sop in self.sops]

ciris_engine/schemas/conscience/__init__.py

@@ -0,0 +1,25 @@
+"""conscience schemas v1."""
+
+from .context import ConscienceCheckContext
+from .core import (
+    CoherenceCheckResult,
+    ConscienceCheckResult,
+    ConscienceStatus,
+    EntropyCheckResult,
+    EpistemicData,
+    EpistemicHumilityResult,
+    OptimizationVetoResult,
+)
+from .results import ConscienceResult
+
+__all__ = [
+    "ConscienceCheckContext",
+    "ConscienceStatus",
+    "EntropyCheckResult",
+    "CoherenceCheckResult",
+    "OptimizationVetoResult",
+    "EpistemicHumilityResult",
+    "EpistemicData",
+    "ConscienceCheckResult",
+    "ConscienceResult",
+]

ciris_engine/schemas/conscience/context.py

@@ -0,0 +1,34 @@
+"""
+Conscience Check Context Schema.
+
+Provides typed context for conscience check operations, replacing Dict[str, Any].
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ConscienceCheckContext(BaseModel):
+    """Context for conscience check operations.
+
+    This schema replaces Dict[str, Any] context parameters in conscience checks,
+    providing type safety while maintaining flexibility for additional context data.
+    """
+
+    # Core context - thought being evaluated
+    thought: Any = Field(..., description="Thought being evaluated (Thought object)")
+
+    # Optional context fields
+    task: Optional[Any] = Field(None, description="Associated task if available (Task object)")
+    round_number: Optional[int] = Field(None, description="Current processing round number")
+    system_snapshot: Optional[Any] = Field(None, description="System state snapshot (SystemSnapshot object)")
+
+    # Additional context can be added via extra fields
+    model_config = ConfigDict(
+        extra="allow",  # Allow additional context fields
+        arbitrary_types_allowed=True,  # Allow runtime objects
+    )
+
+
+__all__ = ["ConscienceCheckContext"]

ciris_engine/schemas/conscience/core.py

@@ -0,0 +1,145 @@
+"""
+Conscience Schemas v1 - Safety check schemas for CIRIS Agent
+
+Provides schemas for conscience validation results and epistemic safety checks.
+"""
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ciris_engine.schemas.types import JSONDict
+
+
+class ConscienceStatus(str, Enum):
+    """Status of a conscience check"""
+
+    PASSED = "passed"
+    FAILED = "failed"
+    WARNING = "warning"
+
+
+class EntropyCheckResult(BaseModel):
+    """Result of entropy safety check"""
+
+    passed: bool = Field(description="Whether the check passed")
+    entropy_score: float = Field(ge=0.0, le=1.0, description="Entropy score (0=low, 1=high)")
+    threshold: float = Field(ge=0.0, le=1.0, description="Threshold used for check")
+    message: str = Field(description="Human-readable result message")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class CoherenceCheckResult(BaseModel):
+    """Result of coherence safety check"""
+
+    passed: bool = Field(description="Whether the check passed")
+    coherence_score: float = Field(ge=0.0, le=1.0, description="Coherence score (0=low, 1=high)")
+    threshold: float = Field(ge=0.0, le=1.0, description="Threshold used for check")
+    message: str = Field(description="Human-readable result message")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class OptimizationVetoResult(BaseModel):
+    """Result of optimization veto check"""
+
+    decision: str = Field(description="Decision: proceed, abort, or defer")
+    justification: str = Field(description="Justification for the decision")
+    entropy_reduction_ratio: float = Field(ge=0.0, description="Estimated entropy reduction ratio")
+    affected_values: List[str] = Field(default_factory=list, description="Values that would be affected")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class EpistemicHumilityResult(BaseModel):
+    """Result of epistemic humility check"""
+
+    epistemic_certainty: float = Field(ge=0.0, le=1.0, description="Level of epistemic certainty")
+    identified_uncertainties: List[str] = Field(default_factory=list, description="Identified uncertainties")
+    reflective_justification: str = Field(description="Reflective justification")
+    recommended_action: str = Field(description="Recommended action: proceed, ponder, or defer")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class EpistemicData(BaseModel):
+    """Epistemic safety metadata - core epistemic metrics only"""
+
+    entropy_level: float = Field(ge=0.0, le=1.0, description="Current entropy level")
+    coherence_level: float = Field(ge=0.0, le=1.0, description="Current coherence level")
+    uncertainty_acknowledged: bool = Field(description="Whether uncertainty was acknowledged")
+    reasoning_transparency: float = Field(ge=0.0, le=1.0, description="Transparency of reasoning")
+    # NEW: Stores the actual content of a new observation that arrived during processing
+    # This is used by UpdatedStatusConscience to pass the new message to retry context
+    CIRIS_OBSERVATION_UPDATED_STATUS: Optional[str] = Field(
+        default=None, description="Content of new observation that arrived during processing"
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ConscienceCheckResult(BaseModel):
+    """Unified result from conscience safety checks"""
+
+    status: ConscienceStatus = Field(description="Overall check status")
+    passed: bool = Field(description="Whether all checks passed")
+    reason: Optional[str] = Field(default=None, description="Reason for failure/warning")
+    epistemic_data: Optional[EpistemicData] = Field(
+        default=None, description="Epistemic safety metadata (provided by epistemic consciences)"
+    )
+
+    # Detailed check results (each conscience provides its own check)
+    entropy_check: Optional[EntropyCheckResult] = Field(default=None, description="Entropy check result")
+    coherence_check: Optional[CoherenceCheckResult] = Field(default=None, description="Coherence check result")
+    optimization_veto_check: Optional[OptimizationVetoResult] = Field(
+        default=None, description="Optimization veto result"
+    )
+    epistemic_humility_check: Optional[EpistemicHumilityResult] = Field(
+        default=None, description="Humility check result"
+    )
+
+    # Metrics
+    entropy_score: Optional[float] = Field(default=None, ge=0.0, le=1.0, description="Overall entropy score")
+    coherence_score: Optional[float] = Field(default=None, ge=0.0, le=1.0, description="Overall coherence score")
+
+    # Processing metadata
+    check_timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), description="When check was performed"
+    )
+    processing_time_ms: Optional[float] = Field(default=None, ge=0.0, description="Processing time in milliseconds")
+
+    # Optional replacement action for conscience checks that override the selected action
+    # Used by ThoughtDepthGuardrail and UpdatedStatusConscience
+    replacement_action: Optional[JSONDict] = Field(
+        default=None, description="Replacement action when conscience overrides"
+    )
+
+    # Optional observation content for UpdatedStatusConscience
+    CIRIS_OBSERVATION_UPDATED_STATUS: Optional[str] = Field(
+        default=None, description="New observation that arrived during processing"
+    )
+    original_action: Optional[JSONDict] = Field(
+        default=None, description="Original action payload evaluated by conscience"
+    )
+    thought_depth_triggered: Optional[bool] = Field(
+        default=None, description="Whether the thought depth guardrail triggered"
+    )
+    updated_status_detected: Optional[bool] = Field(
+        default=None, description="Whether the updated status conscience detected changes"
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+__all__ = [
+    "ConscienceStatus",
+    "EntropyCheckResult",
+    "CoherenceCheckResult",
+    "OptimizationVetoResult",
+    "EpistemicHumilityResult",
+    "EpistemicData",
+    "ConscienceCheckResult",
+]