ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/schemas/runtime/processing_context.py

@@ -0,0 +1,43 @@
+"""
+Processing context schemas for CIRIS.
+
+Provides context objects for thought and task processing that carry
+system state and metadata through the processing pipeline.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .models import TaskContext
+from .system_context import SystemSnapshot, UserProfile
+
+
+class ProcessingThoughtContext(BaseModel):
+    """Context passed through thought processing pipeline.
+
+    This is different from ThoughtContext which represents a thought entity.
+    This context carries processing metadata and system state.
+    """
+
+    # System state snapshot
+    system_snapshot: SystemSnapshot = Field(..., description="Current system state")
+
+    # User and profile data
+    user_profiles: Dict[str, UserProfile] = Field(
+        default_factory=dict, description="User profile data keyed by user_id"
+    )
+
+    # Task history
+    task_history: List[Any] = Field(default_factory=list, description="Recent task history")
+
+    # Identity context
+    identity_context: Optional[str] = Field(None, description="Agent identity context")
+
+    # Initial task context
+    initial_task_context: Optional[TaskContext] = Field(None, description="Original task context")
+
+    model_config = ConfigDict(extra="allow")  # Allow additional fields for flexibility
+
+
+__all__ = ["ProcessingThoughtContext"]

ciris_engine/schemas/runtime/protocols_core.py

@@ -0,0 +1,96 @@
+"""
+Core protocol schemas.
+
+Type-safe schemas for core service operations.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class LLMUsageStatistics(BaseModel):
+    """Token usage statistics for LLM service."""
+
+    total_calls: int = Field(0, description="Total number of calls made")
+    failed_calls: int = Field(0, description="Number of failed calls")
+    success_rate: float = Field(1.0, ge=0.0, le=1.0, description="Success rate (0-1)")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class LLMStatus(BaseModel):
+    """Status information from LLM service."""
+
+    available: bool = Field(..., description="Whether service is available")
+    model: str = Field(..., description="Current model name")
+    usage: LLMUsageStatistics = Field(default_factory=LLMUsageStatistics, description="Token usage statistics")
+    rate_limit_remaining: Optional[int] = Field(None, description="Remaining API calls")
+    response_time_avg: Optional[float] = Field(None, description="Average response time")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class NetworkQueryRequest(BaseModel):
+    """Request for network query."""
+
+    query_type: str = Field(..., description="Type of query (e.g., 'peer_discovery')")
+    parameters: Dict[str, str] = Field(default_factory=dict, description="Query parameters")
+    timeout: Optional[float] = Field(30.0, description="Query timeout")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MetricDataPoint(BaseModel):
+    """A single metric data point."""
+
+    metric_name: str = Field(..., description="Name of the metric")
+    value: float = Field(..., description="Metric value")
+    timestamp: datetime = Field(..., description="When metric was recorded")
+    tags: Dict[str, str] = Field(default_factory=dict, description="Metric tags")
+    service_name: Optional[str] = Field(None, description="Service that recorded metric")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ResourceLimits(BaseModel):
+    """Resource limits and quotas."""
+
+    max_memory_mb: Optional[int] = Field(None, description="Maximum memory in MB")
+    max_cpu_percent: Optional[float] = Field(None, description="Maximum CPU percentage")
+    max_disk_gb: Optional[float] = Field(None, description="Maximum disk usage in GB")
+    max_api_calls_per_minute: Optional[int] = Field(None, description="API rate limit")
+    max_concurrent_operations: Optional[int] = Field(None, description="Max concurrent ops")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SecretInfo(BaseModel):
+    """Information about a stored secret."""
+
+    uuid: str = Field(..., description="Secret UUID")
+    description: str = Field(..., description="Secret description")
+    secret_type: str = Field(..., description="Type of secret")
+    sensitivity: str = Field(..., description="Sensitivity level")
+    created_at: datetime = Field(..., description="When secret was stored")
+    last_accessed: Optional[datetime] = Field(None, description="Last access time")
+    access_count: int = Field(0, description="Number of times accessed")
+    decrypted_value: Optional[str] = Field(None, description="Decrypted value if requested")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SecretsServiceStats(BaseModel):
+    """Statistics from secrets service."""
+
+    secrets_stored: int = Field(..., description="Total secrets in storage")
+    filter_active: bool = Field(..., description="Whether filter is active")
+    patterns_enabled: List[str] = Field(..., description="Enabled detection patterns")
+    recent_detections: int = Field(0, description="Detections in last hour")
+    storage_size_bytes: Optional[int] = Field(None, description="Storage size used")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+__all__ = ["LLMStatus", "NetworkQueryRequest", "MetricDataPoint", "ResourceLimits", "SecretInfo", "SecretsServiceStats"]

ciris_engine/schemas/runtime/resources.py

@@ -0,0 +1,33 @@
+"""
+Resource tracking schemas for CIRIS Trinity Architecture.
+
+Environmental and financial impact tracking for responsible AI.
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ResourceUsage(BaseModel):
+    """Track LLM resource utilization with environmental awareness."""
+
+    # Token usage
+    tokens_used: int = Field(default=0, description="Total tokens consumed")
+    tokens_input: int = Field(default=0, description="Input tokens")
+    tokens_output: int = Field(default=0, description="Output tokens")
+
+    # Financial impact
+    cost_cents: float = Field(default=0.0, ge=0.0, description="Cost in cents USD")
+
+    # Environmental impact
+    carbon_grams: float = Field(default=0.0, ge=0.0, description="Carbon emissions in grams CO2")
+    energy_kwh: float = Field(default=0.0, ge=0.0, description="Energy consumption in kilowatt-hours")
+
+    # Model information
+    model_used: Optional[str] = Field(default=None, description="Model that incurred these costs")
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+
+__all__ = ["ResourceUsage"]

ciris_engine/schemas/runtime/system_context.py

@@ -0,0 +1,417 @@
+"""
+System and runtime context schemas.
+
+Provides type-safe contexts for system state and runtime operations.
+"""
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+
+from ciris_engine.schemas.adapters.tools import ToolInfo
+
+# Import IdentityData for backwards compatibility with new type
+from ciris_engine.schemas.infrastructure.identity_variance import IdentityData
+
+# Import ShutdownContext directly to avoid forward reference issues
+from ciris_engine.schemas.runtime.extended import ShutdownContext
+from ciris_engine.schemas.runtime.resources import ResourceUsage
+
+# Import CircuitBreakerState directly for runtime validation
+from ciris_engine.schemas.services.graph.telemetry import CircuitBreakerState
+from ciris_engine.schemas.types import JSONDict
+
+
+class SystemSnapshot(BaseModel):
+    """System state snapshot for processing context.
+
+    This snapshot captures the system state needed for decision-making during
+    task and thought processing. The most critical field is channel_context,
+    which provides the communication context. All other fields provide
+    supplementary information about current processing state and system health.
+
+    Usage patterns:
+    1. Minimal: SystemSnapshot(channel_context=create_channel_context(channel_id))
+       - Used by: task_manager, shutdown_processor, speak_handler, discord_observer
+
+    2. Full: Built by build_system_snapshot() with all available context
+       - Used during: thought context building in processors
+
+    Field usage:
+    - ALWAYS SET: channel_context, channel_id
+    - COMMONLY SET: current_task_details, current_thought_summary, system_counts
+    - IDENTITY FIELDS: agent_identity and related fields loaded from graph
+    - RUNTIME FIELDS: service_health, circuit_breaker_status from service registry
+    - SECURITY FIELDS: detected_secrets and related from secrets service
+    """
+
+    # Channel context (PRIMARY FIELDS - almost always set)
+    channel_id: Optional[str] = Field(
+        None, description="ID of the communication channel (e.g., Discord channel ID, 'cli', 'api')"
+    )
+    channel_context: Optional["ChannelContext"] = Field(
+        None, description="Full channel context with metadata - the most important field"
+    )
+
+    # Current processing state (set when processing tasks/thoughts)
+    current_task_details: Optional["TaskSummary"] = Field(
+        None, description="Summary of the task currently being processed"
+    )
+    current_thought_summary: Optional["ThoughtSummary"] = Field(
+        None, description="Summary of the thought currently being processed"
+    )
+
+    # System overview (computed during snapshot building)
+    system_counts: Dict[str, int] = Field(
+        default_factory=dict, description="Counts: total_tasks, total_thoughts, pending_tasks, pending_thoughts"
+    )
+    top_pending_tasks_summary: List["TaskSummary"] = Field(
+        default_factory=list, description="Top 10 pending tasks by priority"
+    )
+    recently_completed_tasks_summary: List["TaskSummary"] = Field(
+        default_factory=list, description="10 most recently completed tasks"
+    )
+
+    # Agent identity (loaded once from graph memory)
+    # Accepts both IdentityData model and JSONDict for backwards compatibility
+    agent_identity: IdentityData | JSONDict = Field(
+        default_factory=lambda: {}, description="Raw agent identity data from graph node"
+    )
+    identity_purpose: Optional[str] = Field(None, description="Agent's purpose statement extracted from identity")
+    identity_capabilities: List[str] = Field(
+        default_factory=list, description="List of agent capabilities from identity"
+    )
+    identity_restrictions: List[str] = Field(
+        default_factory=list, description="List of agent restrictions from identity"
+    )
+
+    # Version information
+    agent_version: Optional[str] = Field(None, description="CIRIS agent version (e.g., 1.0.4-beta)")
+    agent_codename: Optional[str] = Field(None, description="Release codename (e.g., Graceful Guardian)")
+    agent_code_hash: Optional[str] = Field(None, description="Code hash for exact version identification")
+
+    # Security context (from secrets service)
+    detected_secrets: List[str] = Field(
+        default_factory=list, description="Patterns of secrets detected in current context (masked representations)"
+    )
+    secrets_filter_version: int = Field(0, description="Version of the secrets filter being used")
+    total_secrets_stored: int = Field(0, description="Total number of secrets in secure storage")
+
+    # Service health (from service registry)
+    service_health: Dict[str, bool] = Field(
+        default_factory=dict, description="Health status of each service (service_name -> is_healthy)"
+    )
+    circuit_breaker_status: Dict[str, str] = Field(
+        default_factory=dict, description="Circuit breaker status for each service (service_name -> state)"
+    )
+
+    # Runtime context
+    shutdown_context: Optional[ShutdownContext] = Field(None, description="Shutdown context if system is shutting down")
+    current_time_utc: str = Field(default="", description="Current system time in UTC ISO format from time service")
+    current_time_london: str = Field(default="", description="Current time in London timezone (Europe/London)")
+    current_time_chicago: str = Field(default="", description="Current time in Chicago timezone (America/Chicago)")
+    current_time_tokyo: str = Field(default="", description="Current time in Tokyo timezone (Asia/Tokyo)")
+
+    # Resource alerts - CRITICAL for mission-critical systems
+    resource_alerts: List[str] = Field(
+        default_factory=list, description="CRITICAL resource alerts that require immediate attention"
+    )
+
+    # User profiles (used by context builder)
+    user_profiles: List["UserProfile"] = Field(default_factory=list, description="User profile information")
+
+    # Telemetry summary for resource usage
+    telemetry_summary: Optional["TelemetrySummary"] = Field(
+        None, description="Aggregated telemetry data for resource usage tracking"
+    )
+
+    # Continuity awareness - agent lifecycle metrics
+    continuity_summary: Optional["ContinuitySummary"] = Field(
+        None, description="Continuity awareness metrics across shutdowns and restarts"
+    )
+
+    # Adapter channels - for agent visibility into available communication channels
+    # Type-safe: Use ChannelContext objects from processors.base, not dicts
+    # Using forward reference to avoid circular import
+    adapter_channels: Dict[str, List["ChannelContext"]] = Field(
+        default_factory=dict, description="Available channels by adapter type with ChannelContext objects"
+    )
+
+    # Available tools - for agent visibility into tools across all adapters
+    available_tools: Dict[str, List[ToolInfo]] = Field(
+        default_factory=dict, description="Available tools by adapter type with full ToolInfo objects"
+    )
+
+    # Context enrichment results - pre-run tool results for context-aware action selection
+    # These are populated by running tools marked with context_enrichment=True
+    # Key is "adapter_type:tool_name", value is the tool result data
+    context_enrichment_results: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Results from tools marked with context_enrichment=True, keyed by adapter_type:tool_name",
+    )
+
+    model_config = ConfigDict(extra="forbid")  # Be strict about fields to catch misuse
+
+
+class TaskSummary(BaseModel):
+    """Summary of a task for system snapshot."""
+
+    task_id: str = Field(..., description="Unique task identifier")
+    channel_id: str = Field(..., description="Channel where task originated")
+    created_at: datetime = Field(..., description="Task creation time")
+    status: str = Field(..., description="Current task status")
+
+    # Task metadata
+    priority: int = Field(0, description="Task priority")
+    retry_count: int = Field(0, description="Number of retries")
+    parent_task_id: Optional[str] = Field(None, description="Parent task if nested")
+
+    # Execution context
+    assigned_agent: Optional[str] = Field(None, description="Agent handling the task")
+    deadline: Optional[datetime] = Field(None, description="Task deadline")
+    tags: List[str] = Field(default_factory=list, description="Task tags")
+
+    # Results
+    result: Optional[str] = Field(None, description="Task result")
+    result_data: Optional[Dict[str, str]] = Field(None, description="Structured result data")
+    error: Optional[str] = Field(None, description="Error if failed")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ThoughtState(BaseModel):
+    """State for a thought being processed."""
+
+    thought_id: str = Field(..., description="Unique thought identifier")
+    task_id: str = Field(..., description="Associated task ID")
+    content: str = Field(..., description="Thought content")
+    thought_type: str = Field(..., description="Type of thought")
+
+    # Processing state
+    created_at: datetime = Field(..., description="When thought was created")
+    processing_depth: int = Field(0, description="How many times processed")
+    is_pondering: bool = Field(False, description="Whether in ponder state")
+
+    # Relationships
+    parent_thought_id: Optional[str] = Field(None, description="Parent thought if nested")
+    child_thought_ids: List[str] = Field(default_factory=list, description="Child thoughts")
+
+    # DMA results (stored as JSON strings for flexibility)
+    pdma_result: Optional[str] = Field(None, description="PDMA evaluation JSON")
+    csdma_result: Optional[str] = Field(None, description="CSDMA evaluation JSON")
+    dsdma_result: Optional[str] = Field(None, description="DSDMA evaluation JSON")
+
+    # Decision
+    selected_action: Optional[str] = Field(None, description="Action selected")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class UserProfile(BaseModel):
+    """User profile information."""
+
+    user_id: str = Field(..., description="Unique user identifier")
+    display_name: str = Field(..., description="User display name")
+    created_at: datetime = Field(..., description="Profile creation time")
+
+    # Preferences
+    preferred_language: str = Field("en", description="Preferred language code")
+    timezone: str = Field("UTC", description="User timezone")
+    communication_style: str = Field("formal", description="Preferred communication style")
+
+    # User-configurable preferences (protected from agent, modifiable via API only)
+    user_preferred_name: Optional[str] = Field(None, description="User's preferred display name (overrides oauth_name)")
+    location: Optional[str] = Field(None, description="User's location preference")
+    interaction_preferences: Optional[str] = Field(
+        None, description="User's custom interaction preferences/prompt (free-form text)"
+    )
+    oauth_name: Optional[str] = Field(None, description="Full name from OAuth provider")
+
+    # Interaction history
+    total_interactions: int = Field(0, description="Total interactions")
+    last_interaction: Optional[datetime] = Field(None, description="Last interaction time")
+    trust_level: float = Field(0.5, description="Trust level (0.0-1.0)")
+
+    # Permissions
+    is_wa: bool = Field(False, description="Whether user is Wise Authority")
+    permissions: List[str] = Field(default_factory=list, description="Granted permissions")
+    restrictions: List[str] = Field(default_factory=list, description="Applied restrictions")
+
+    # Consent relationship state (v1.4.6)
+    consent_stream: str = Field("TEMPORARY", description="Consent stream: TEMPORARY, PARTNERED, or ANONYMOUS")
+    consent_expires_at: Optional[datetime] = Field(None, description="When TEMPORARY consent expires (14 days)")
+    partnership_requested_at: Optional[datetime] = Field(None, description="When partnership was requested")
+    partnership_approved: bool = Field(False, description="Whether partnership was approved by agent")
+
+    # Agent memorized data - arbitrary attributes the agent chose to store about this user
+    memorized_attributes: Dict[str, str] = Field(
+        default_factory=dict, description="Additional attributes the agent memorized about this user"
+    )
+
+    # Additional context
+    notes: Optional[str] = Field(None, description="Additional notes or context about the user")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ChannelContext(BaseModel):
+    """Context for a communication channel."""
+
+    channel_id: str = Field(..., description="Unique channel identifier")
+    channel_type: str = Field(..., description="Type of channel (discord, cli, api)")
+    created_at: datetime = Field(..., description="Channel creation time")
+
+    # Channel metadata
+    channel_name: Optional[str] = Field(None, description="Human-readable channel name")
+    is_private: bool = Field(False, description="Whether channel is private")
+    participants: List[str] = Field(default_factory=list, description="Channel participants")
+
+    # State
+    is_active: bool = Field(True, description="Whether channel is active")
+    last_activity: Optional[datetime] = Field(None, description="Last activity time")
+    message_count: int = Field(0, description="Total messages in channel")
+
+    # Configuration
+    allowed_actions: List[str] = Field(default_factory=list, description="Allowed actions in channel")
+    moderation_level: str = Field("standard", description="Moderation level")
+
+    # Agent memorized data - arbitrary attributes the agent chose to store about this channel
+    memorized_attributes: Dict[str, str] = Field(
+        default_factory=dict, description="Additional attributes the agent memorized about this channel"
+    )
+
+    @field_serializer("created_at", "last_activity")
+    def serialize_datetimes(self, dt: Optional[datetime], _info: Any) -> Optional[str]:
+        return dt.isoformat() if dt else None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class AuditVerification(BaseModel):
+    """Audit chain verification result."""
+
+    verified_at: datetime = Field(..., description="When verification occurred")
+    result: str = Field(..., description="Verification result: valid, invalid, partial")
+    entries_verified: int = Field(..., description="Number of entries verified")
+    hash_chain_valid: bool = Field(..., description="Whether hash chain is intact")
+    signatures_valid: bool = Field(..., description="Whether signatures are valid")
+
+    # Issues found
+    issues: List[str] = Field(default_factory=list, description="Issues found during verification")
+    missing_entries: List[str] = Field(default_factory=list, description="Missing entry IDs")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ThoughtSummary(BaseModel):
+    """Summary of a thought for context."""
+
+    thought_id: str = Field(..., description="Thought ID")
+    content: Optional[str] = Field(None, description="Thought content")
+    status: Optional[str] = Field(None, description="Thought status")
+    source_task_id: Optional[str] = Field(None, description="Source task ID")
+    thought_type: Optional[str] = Field(None, description="Type of thought")
+    thought_depth: Optional[int] = Field(None, description="Processing depth")
+
+    model_config = ConfigDict(extra="allow")
+
+
+class TelemetrySummary(BaseModel):
+    """Summary of recent telemetry metrics for system context."""
+
+    # Time window
+    window_start: datetime = Field(..., description="Start of telemetry window")
+    window_end: datetime = Field(..., description="End of telemetry window")
+    uptime_seconds: float = Field(..., description="System uptime in seconds")
+
+    # Activity metrics (last 24h)
+    messages_processed_24h: int = Field(0, description="Messages processed in last 24h")
+    thoughts_processed_24h: int = Field(0, description="Thoughts processed in last 24h")
+    tasks_completed_24h: int = Field(0, description="Tasks completed in last 24h")
+    errors_24h: int = Field(0, description="Errors in last 24h")
+
+    # Current hour metrics
+    messages_current_hour: int = Field(0, description="Messages this hour")
+    thoughts_current_hour: int = Field(0, description="Thoughts this hour")
+    errors_current_hour: int = Field(0, description="Errors this hour")
+
+    # Service breakdowns
+    service_calls: Dict[str, int] = Field(default_factory=dict, description="Calls per service type")
+    service_errors: Dict[str, int] = Field(default_factory=dict, description="Errors per service type")
+    service_latency_ms: Dict[str, float] = Field(default_factory=dict, description="Avg latency per service")
+
+    # Resource consumption totals (actuals for the last hour)
+    tokens_last_hour: float = Field(0.0, description="Total tokens used in the last hour")
+    cost_last_hour_cents: float = Field(0.0, description="Total cost in the last hour (cents)")
+    carbon_last_hour_grams: float = Field(0.0, description="Total carbon emissions in the last hour (grams)")
+    energy_last_hour_kwh: float = Field(0.0, description="Total energy usage in the last hour (kWh)")
+
+    # Resource consumption totals (actuals for the last 24 hours)
+    tokens_24h: float = Field(0.0, description="Total tokens used in the last 24 hours")
+    cost_24h_cents: float = Field(0.0, description="Total cost in the last 24 hours (cents)")
+    carbon_24h_grams: float = Field(0.0, description="Total carbon emissions in the last 24 hours (grams)")
+    energy_24h_kwh: float = Field(0.0, description="Total energy usage in the last 24 hours (kWh)")
+
+    # Health indicators
+    error_rate_percent: float = Field(0.0, description="Error rate as percentage")
+    avg_thought_depth: float = Field(0.0, description="Average thought processing depth")
+    queue_saturation: float = Field(0.0, description="Queue saturation 0-1")
+
+    # Circuit breaker state
+    circuit_breaker: Optional[Dict[str, CircuitBreakerState]] = Field(
+        None, description="Circuit breaker state across all services (service_name -> CircuitBreakerState)"
+    )
+
+    @field_serializer("window_start", "window_end")
+    def serialize_datetimes(self, dt: datetime, _info: Any) -> Optional[str]:
+        return dt.isoformat() if dt else None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ContinuitySummary(BaseModel):
+    """Summary of agent continuity across shutdowns and restarts."""
+
+    # First startup time
+    first_startup: Optional[datetime] = Field(None, description="Timestamp of very first agent startup")
+
+    # Lifetime metrics
+    total_time_online_seconds: float = Field(0.0, description="Total cumulative time agent has been online")
+    total_time_offline_seconds: float = Field(0.0, description="Total cumulative time agent has been offline")
+    total_shutdowns: int = Field(0, description="Total number of shutdowns in agent's lifetime")
+
+    # Averages
+    average_time_online_seconds: float = Field(0.0, description="Average time online per session")
+    average_time_offline_seconds: float = Field(0.0, description="Average time offline between sessions")
+
+    # Current session
+    current_session_start: Optional[datetime] = Field(None, description="When current session started")
+    current_session_duration_seconds: float = Field(0.0, description="Duration of current session")
+
+    # Last shutdown
+    last_shutdown: Optional[datetime] = Field(None, description="When last shutdown occurred")
+    last_shutdown_reason: Optional[str] = Field(None, description="Reason for last shutdown")
+    last_shutdown_consent: Optional[str] = Field(
+        None, description="Consent status: 'accepted', 'rejected', or 'manual' (crashes/forced)"
+    )
+
+    @field_serializer("first_startup", "current_session_start", "last_shutdown")
+    def serialize_datetimes(self, dt: Optional[datetime], _info: Any) -> Optional[str]:
+        return dt.isoformat() if dt else None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+__all__ = [
+    "SystemSnapshot",
+    "TaskSummary",
+    "ThoughtState",
+    "UserProfile",
+    "ChannelContext",
+    "ResourceUsage",  # Re-exported from resources module
+    "AuditVerification",
+    "TelemetrySummary",
+    "ThoughtSummary",
+    "ContinuitySummary",
+]

ciris_engine/schemas/secrets/__init__.py

@@ -0,0 +1 @@
+"""Package initialization."""