ciris-agent 1.7.7__py3-none-any.whl

ciris_engine/logic/handlers/control/defer_handler.py

@@ -0,0 +1,195 @@
+import logging
+from datetime import datetime
+from typing import Any, Optional
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.infrastructure.handlers.base_handler import BaseActionHandler
+from ciris_engine.schemas.actions import DeferParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, TaskStatus, ThoughtStatus
+from ciris_engine.schemas.runtime.models import Thought
+from ciris_engine.schemas.services.context import DeferralContext
+
+logger = logging.getLogger(__name__)
+
+
+class DeferHandler(BaseActionHandler):
+    def _is_api_channel(self, channel_id: Optional[str]) -> bool:
+        """Check if channel is an API channel (not Discord)."""
+        if not channel_id:
+            return False
+        return channel_id.startswith("api_") or channel_id.startswith("ws:")
+
+    async def _get_task_scheduler_service(self) -> Optional[Any]:
+        """Get task scheduler service from registry."""
+        try:
+            if hasattr(self, "_service_registry") and self._service_registry:
+                # Try to get from service registry
+                return await self._service_registry.get_service(handler="task_scheduler", service_type="scheduler")
+            else:
+                logger.debug("No _service_registry available for task scheduler lookup")
+        except Exception as e:
+            logger.warning(f"Could not get task scheduler service: {e}")
+        return None
+
+    async def handle(
+        self,
+        result: ActionSelectionDMAResult,  # Updated to v1 result schema
+        thought: Thought,
+        dispatch_context: DispatchContext,
+    ) -> Optional[str]:
+        raw_params = result.action_parameters
+        thought_id = thought.thought_id
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        final_thought_status = ThoughtStatus.DEFERRED
+        action_performed_successfully = False
+        follow_up_content_key_info = f"DEFER action for thought {thought_id}"
+
+        defer_params_obj: Optional[DeferParams] = None
+        try:
+            # Check if params are already DeferParams
+            if isinstance(raw_params, DeferParams):
+                defer_params_obj = raw_params
+            elif hasattr(raw_params, "model_dump"):
+                # Try to convert from another Pydantic model
+                defer_params_obj = DeferParams(**raw_params.model_dump())
+            else:
+                # Should not happen if DMA is working correctly
+                raise ValueError(f"Expected DeferParams but got {type(raw_params)}")
+
+            follow_up_content_key_info = f"Deferred thought {thought_id}. Reason: {defer_params_obj.reason}"
+
+            # Check if this is a time-based deferral
+            if defer_params_obj.defer_until:
+                # Schedule the task for future reactivation
+                scheduler_service = await self._get_task_scheduler_service()
+                if scheduler_service:
+                    try:
+                        # Parse the defer_until timestamp - handle both 'Z' and '+00:00' formats
+                        defer_str = defer_params_obj.defer_until
+                        if defer_str.endswith("Z"):
+                            defer_str = defer_str[:-1] + "+00:00"
+                        defer_time = datetime.fromisoformat(defer_str)
+
+                        # Create scheduled task
+                        scheduled_task = await scheduler_service.schedule_deferred_task(
+                            thought_id=thought_id,
+                            task_id=thought.source_task_id,
+                            defer_until=defer_params_obj.defer_until,
+                            reason=defer_params_obj.reason,
+                            context=defer_params_obj.context,
+                        )
+
+                        logger.info(
+                            f"Created scheduled task {scheduled_task.task_id} to reactivate at {defer_params_obj.defer_until}"
+                        )
+
+                        # Add scheduled info to follow-up content
+                        time_diff = defer_time - self.time_service.now()
+                        hours = int(time_diff.total_seconds() / 3600)
+                        minutes = int((time_diff.total_seconds() % 3600) / 60)
+
+                        follow_up_content_key_info = (
+                            f"Deferred thought {thought_id} until {defer_params_obj.defer_until} "
+                            f"({hours}h {minutes}m from now). Reason: {defer_params_obj.reason}"
+                        )
+                    except Exception as e:
+                        logger.error(f"Failed to schedule deferred task: {e}")
+                        # Fall back to standard deferral
+
+            # Use the wise authority bus for deferrals
+            try:
+                # Build metadata dict for additional context
+                metadata = {
+                    "attempted_action": getattr(dispatch_context, "attempted_action", "unknown"),
+                    "max_rounds_reached": str(getattr(dispatch_context, "max_rounds_reached", False)),
+                }
+
+                if thought.source_task_id:
+                    task = persistence.get_task_by_id(thought.source_task_id)
+                    if task and hasattr(task, "description"):
+                        metadata["task_description"] = task.description
+
+                # Convert defer_until from ISO string to datetime if present
+                defer_until_dt = None
+                if defer_params_obj.defer_until:
+                    defer_until_dt = datetime.fromisoformat(defer_params_obj.defer_until.replace("Z", "+00:00"))
+
+                deferral_context = DeferralContext(
+                    thought_id=thought_id,
+                    task_id=thought.source_task_id,
+                    reason=defer_params_obj.reason,
+                    defer_until=defer_until_dt,
+                    priority=getattr(defer_params_obj, "priority", "medium"),
+                    metadata=metadata,
+                )
+
+                wa_sent = await self.bus_manager.wise.send_deferral(
+                    context=deferral_context, handler_name=self.__class__.__name__
+                )
+                if not wa_sent:
+                    logger.info(
+                        f"Marked thought {thought_id} and task {thought.source_task_id} as deferred, but no WA service is available to deliver the deferral package"
+                    )
+                else:
+                    logger.info(f"Successfully sent deferral to WA service for thought {thought_id}")
+                action_performed_successfully = True
+            except Exception as e:
+                self.logger.error(f"WiseAuthorityService deferral failed for thought {thought_id}: {e}")
+                # Deferral still considered processed even if WA fails
+
+        except Exception as param_parse_error:
+            self.logger.error(
+                f"DEFER action params parsing error or unexpected structure. Type: {type(raw_params)}, Error: {param_parse_error}. Thought ID: {thought_id}"
+            )
+            follow_up_content_key_info = f"DEFER action failed: Invalid parameters ({type(raw_params)}) for thought {thought_id}. Error: {param_parse_error}"
+            # Try to send deferral despite parameter error
+            try:
+                error_context = DeferralContext(
+                    thought_id=thought_id,
+                    task_id=thought.source_task_id,
+                    reason="parameter_error",
+                    defer_until=None,
+                    priority=None,
+                    metadata={
+                        "error_type": "parameter_parsing_error",
+                        "attempted_action": getattr(dispatch_context, "attempted_action", "defer"),
+                    },
+                )
+                wa_sent = await self.bus_manager.wise.send_deferral(
+                    context=error_context, handler_name=self.__class__.__name__
+                )
+                if not wa_sent:
+                    logger.info(
+                        f"Marked thought {thought_id} as deferred (parameter error), but no WA service is available to deliver the deferral package"
+                    )
+            except Exception as e_sink_fallback:
+                self.logger.error(f"Fallback deferral submission failed for thought {thought_id}: {e_sink_fallback}")
+                _action_performed_successfully = True
+
+        persistence.update_thought_status(
+            thought_id=thought_id,
+            status=final_thought_status,  # Should be DEFERRED
+            final_action=result,  # Pass the ActionSelectionDMAResult object directly
+        )
+        self.logger.info(
+            f"Updated original thought {thought_id} to status {final_thought_status.value} for DEFER action. Info: {follow_up_content_key_info}"
+        )
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        parent_task_id = thought.source_task_id
+        # Update task status to deferred - "no kings" principle
+        persistence.update_task_status(parent_task_id, TaskStatus.DEFERRED, "default", self.time_service)
+        self.logger.info(f"Marked parent task {parent_task_id} as DEFERRED due to child thought deferral.")
+
+        # Send deferral notification to API channels
+        task = persistence.get_task_by_id(parent_task_id)
+        if task and task.channel_id and self._is_api_channel(task.channel_id):
+            self.logger.info(f"Sending deferral notification to API channel {task.channel_id}")
+            await self._send_notification(
+                task.channel_id, "The agent chose to defer, check the wise authority panel if you are the setup user"
+            )
+
+        return None

ciris_engine/logic/handlers/control/ponder_handler.py

@@ -0,0 +1,154 @@
+import logging
+from typing import List, Optional
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.infrastructure.handlers.base_handler import ActionHandlerDependencies, BaseActionHandler
+from ciris_engine.schemas.actions import PonderParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, ThoughtStatus
+from ciris_engine.schemas.runtime.models import Thought
+
+# Configuration handled through ActionHandlerDependencies
+
+logger = logging.getLogger(__name__)
+
+
+class PonderHandler(BaseActionHandler):
+    """Handler for PONDER actions with configurable thought depth limits.
+
+    The max_rounds parameter controls the maximum thought depth before
+    the thought depth conscience intervenes. Default is 7 rounds.
+
+    Note: max_rounds can be passed via constructor for testing/customization.
+    Future enhancement: Load from EssentialConfig.default_max_thought_depth.
+    """
+
+    def __init__(self, dependencies: ActionHandlerDependencies, max_rounds: Optional[int] = None) -> None:
+        super().__init__(dependencies)
+        # Default to 7 rounds if not explicitly set
+        # Can be overridden via constructor parameter for testing
+        self.max_rounds = max_rounds if max_rounds is not None else 7
+
+    async def handle(
+        self,
+        result: ActionSelectionDMAResult,  # Updated to v1 result schema
+        thought: Thought,
+        dispatch_context: DispatchContext,
+    ) -> Optional[str]:
+        """Process ponder action and update thought."""
+        params = result.action_parameters
+        # Handle the union type properly
+        if isinstance(params, PonderParams):
+            ponder_params = params
+        elif hasattr(params, "model_dump"):
+            # Try to convert from another Pydantic model
+            try:
+                ponder_params = PonderParams(**params.model_dump())
+            except Exception as e:
+                logger.warning(f"Failed to convert {type(params)} to PonderParams: {e}")
+                ponder_params = PonderParams(questions=[])
+        else:
+            # Should not happen if DMA is working correctly
+            logger.warning(f"Expected PonderParams but got {type(params)}")
+            ponder_params = PonderParams(questions=[])
+
+        questions_list = ponder_params.questions if hasattr(ponder_params, "questions") else []
+
+        # Note: epistemic_data handling removed - not part of typed DispatchContext
+        # If epistemic data is needed, it should be passed through proper typed fields
+
+        current_thought_depth = thought.thought_depth
+        # Calculate actual follow-up depth (capped at 7 by create_follow_up_thought)
+        new_thought_depth = min(current_thought_depth + 1, 7)
+
+        logger.info(
+            f"Thought ID {thought.thought_id} pondering (current_depth={current_thought_depth}, "
+            f"follow_up_depth={new_thought_depth}). Questions: {questions_list}"
+        )
+
+        # The thought depth conscience will handle max depth enforcement
+        # We just need to process the ponder normally
+        next_status = ThoughtStatus.COMPLETED
+
+        # Get task context for follow-up
+        original_task = persistence.get_task_by_id(thought.source_task_id)
+        task_context = f"Task ID: {thought.source_task_id}"
+        if original_task:
+            task_context = original_task.description
+
+        follow_up_content = self._generate_ponder_follow_up_content(
+            task_context, questions_list, new_thought_depth, thought
+        )
+
+        # Use centralized method to complete thought and create follow-up
+        follow_up_id = self.complete_thought_and_create_followup(
+            thought=thought, follow_up_content=follow_up_content, action_result=result
+        )
+
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        return follow_up_id
+
+    def _generate_ponder_follow_up_content(
+        self, task_context: str, questions_list: List[str], thought_depth: int, thought: Thought
+    ) -> str:
+        """Generate dynamic follow-up content based on ponder count and previous failures.
+
+        IMPORTANT: This method accumulates context across ponder iterations.
+        Each follow-up should include:
+        1. The parent thought's content (accumulated history)
+        2. The current ponder questions/conscience feedback
+        3. Depth-specific guidance
+        """
+        # Start with accumulated history from parent thought
+        accumulated_history = ""
+        if thought.content:
+            # Include parent thought content to preserve history
+            accumulated_history = f"=== PREVIOUS CONTEXT ===\n{thought.content}\n\n"
+
+        # Format current ponder round
+        current_round = f"=== PONDER ROUND {thought_depth} ===\n"
+        if questions_list:
+            current_round += "Conscience feedback:\n"
+            for i, q in enumerate(questions_list, 1):
+                current_round += f"  {i}. {q}\n"
+
+        # Add thought-depth specific guidance
+        if thought_depth <= 3:
+            guidance = f'Task: "{task_context}"\n' "Continue making progress. Consider the conscience feedback above."
+        elif thought_depth <= 5:
+            guidance = (
+                f'Task: "{task_context}"\n'
+                "You're deep into this task. Consider:\n"
+                "1) Is the task nearly complete?\n"
+                "2) Can you address the conscience concerns with a modified approach?\n"
+                f"3) You have {7 - thought_depth + 1} actions remaining."
+            )
+        elif thought_depth == 6:
+            guidance = (
+                f'Task: "{task_context}"\n'
+                "Approaching action limit. Consider:\n"
+                "1) Can you complete with one more action?\n"
+                "2) Is TASK_COMPLETE appropriate?\n"
+                "3) If you need more actions, someone can ask you to continue."
+            )
+        else:  # thought_depth >= 7
+            guidance = (
+                f'Task: "{task_context}"\n'
+                "FINAL ACTION. You should either:\n"
+                "1) TASK_COMPLETE - If work is substantially complete\n"
+                "2) DEFER - Only if you truly need human help\n"
+                "Note: Someone can ask you to continue for 7 more actions."
+            )
+
+        # Combine all parts
+        follow_up_content = accumulated_history + current_round + "\n" + guidance
+
+        # Also include ponder_notes for backwards compatibility
+        if thought.ponder_notes:
+            follow_up_content += "\n\n=== PONDER NOTES ===\n"
+            for note in thought.ponder_notes[-5:]:  # Last 5 entries for more context
+                follow_up_content += f"- {note}\n"
+
+        return follow_up_content

ciris_engine/logic/handlers/control/reject_handler.py

@@ -0,0 +1,81 @@
+import logging
+from typing import Optional
+
+from ciris_engine.logic import persistence
+from ciris_engine.logic.infrastructure.handlers.base_handler import BaseActionHandler
+from ciris_engine.logic.utils.channel_utils import extract_channel_id
+from ciris_engine.schemas.actions import RejectParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, TaskStatus, ThoughtStatus
+from ciris_engine.schemas.runtime.models import Thought
+
+logger = logging.getLogger(__name__)
+
+
+class RejectHandler(BaseActionHandler):
+    async def handle(
+        self, result: ActionSelectionDMAResult, thought: Thought, dispatch_context: DispatchContext
+    ) -> Optional[str]:
+        raw_params = result.action_parameters
+        thought_id = thought.thought_id
+        parent_task_id = thought.source_task_id
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+        original_event_channel_id = extract_channel_id(dispatch_context.channel_context)
+
+        final_thought_status = ThoughtStatus.FAILED
+        _action_performed_successfully = False
+        follow_up_content_key_info = f"REJECT action for thought {thought_id}"
+
+        try:
+            params: RejectParams = self._validate_and_convert_params(raw_params, RejectParams)
+        except Exception as e:
+            await self._handle_error(HandlerActionType.REJECT, dispatch_context, thought_id, e)
+            # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+            persistence.update_thought_status(
+                thought_id=thought_id,
+                status=final_thought_status,
+                final_action=result,
+            )
+            return None
+
+        follow_up_content_key_info = f"Rejected thought {thought_id}. Reason: {params.reason}"
+
+        # Send rejection notification to API channels
+        if original_event_channel_id and self._is_api_channel(original_event_channel_id):
+            self.logger.info(f"Sending rejection notification to API channel {original_event_channel_id}")
+            await self._send_notification(original_event_channel_id, "Agent rejected the message")
+
+        persistence.update_thought_status(
+            thought_id=thought_id,
+            status=final_thought_status,
+            final_action=result,
+        )
+        if parent_task_id:
+            persistence.update_task_status(parent_task_id, TaskStatus.REJECTED, "default", self.time_service)
+        self.logger.info(
+            f"Updated original thought {thought_id} to status {final_thought_status.value} for REJECT action. Info: {follow_up_content_key_info}"
+        )
+
+        # Handle adaptive filtering if requested
+        if isinstance(params, RejectParams) and params.create_filter:
+            await self._create_adaptive_filter(params, thought, dispatch_context)
+
+        # REJECT is a terminal action - no follow-up thoughts should be created
+        self.logger.info(f"REJECT action completed for thought {thought_id}. This is a terminal action.")
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        return None
+
+    def _is_api_channel(self, channel_id: Optional[str]) -> bool:
+        """Check if channel is an API channel (not Discord)."""
+        if not channel_id:
+            return False
+        return channel_id.startswith("api_") or channel_id.startswith("ws:")
+
+    async def _create_adaptive_filter(
+        self, params: RejectParams, thought: Thought, dispatch_context: DispatchContext
+    ) -> None:
+        """Create an adaptive filter based on the rejected content."""
+        # TODO: Implement filter bus when needed
+        self.logger.info("Adaptive filter creation not implemented in new bus architecture")

ciris_engine/logic/handlers/external/__init__.py

@@ -0,0 +1 @@
+"""External handlers module."""

ciris_engine/logic/handlers/external/observe_handler.py

@@ -0,0 +1,154 @@
+import logging
+from typing import List, Optional
+
+from ciris_engine.logic.infrastructure.handlers.base_handler import BaseActionHandler
+from ciris_engine.logic.infrastructure.handlers.exceptions import FollowUpCreationError
+from ciris_engine.logic.utils.channel_utils import extract_channel_id
+from ciris_engine.schemas.actions import ObserveParams
+from ciris_engine.schemas.dma.results import ActionSelectionDMAResult
+from ciris_engine.schemas.runtime.contexts import DispatchContext
+from ciris_engine.schemas.runtime.enums import HandlerActionType, ThoughtStatus
+from ciris_engine.schemas.runtime.messages import FetchedMessage
+from ciris_engine.schemas.runtime.models import Thought
+from ciris_engine.schemas.runtime.system_context import ChannelContext
+from ciris_engine.schemas.services.graph_core import GraphScope, NodeType
+
+PASSIVE_OBSERVE_LIMIT = 10
+ACTIVE_OBSERVE_LIMIT = 50
+
+logger = logging.getLogger(__name__)
+
+
+class ObserveHandler(BaseActionHandler):
+
+    async def _recall_from_messages(
+        self,
+        channel_id: Optional[str],
+        messages: List[FetchedMessage],
+    ) -> None:
+        recall_ids = set()
+        if channel_id:
+            recall_ids.add(f"channel/{channel_id}")
+        for msg in messages or []:
+            aid = msg.author_id if hasattr(msg, "author_id") else getattr(msg, "author_id", None)
+            if aid:
+                recall_ids.add(f"user/{aid}")
+        for rid in recall_ids:
+            for scope in (
+                GraphScope.IDENTITY,
+                GraphScope.ENVIRONMENT,
+                GraphScope.LOCAL,
+            ):
+                try:
+                    if rid.startswith("channel/"):
+                        node_type = NodeType.CHANNEL
+                    elif rid.startswith("user/"):
+                        node_type = NodeType.USER
+                    else:
+                        node_type = NodeType.CONCEPT
+
+                    from ciris_engine.schemas.services.operations import MemoryQuery
+
+                    query = MemoryQuery(node_id=rid, scope=scope, type=node_type, include_edges=False, depth=1)
+                    await self.bus_manager.memory.recall(recall_query=query, handler_name=self.__class__.__name__)
+                except Exception:
+                    continue
+
+    async def handle(
+        self,
+        result: ActionSelectionDMAResult,
+        thought: Thought,
+        dispatch_context: DispatchContext,
+    ) -> Optional[str]:
+        raw_params = result.action_parameters
+        thought_id = thought.thought_id
+
+        logger.info(f"ObserveHandler: Starting handle for thought {thought_id}")
+        logger.debug(f"ObserveHandler: Parameters: {raw_params}")
+        logger.debug(f"ObserveHandler: Dispatch context fields: {list(dispatch_context.__class__.model_fields.keys())}")
+
+        # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+
+        final_status = ThoughtStatus.COMPLETED
+        action_performed = False
+        follow_up_info = f"OBSERVE action for thought {thought_id}"
+
+        try:
+            params: ObserveParams = self._validate_and_convert_params(raw_params, ObserveParams)
+            assert isinstance(params, ObserveParams)  # Type assertion after validation
+        except Exception as e:
+            await self._handle_error(HandlerActionType.OBSERVE, dispatch_context, thought_id, e)
+            # Mark thought as failed and create error follow-up
+            return self.complete_thought_and_create_followup(
+                thought=thought, follow_up_content=f"OBSERVE action failed: {e}", action_result=result
+            )
+
+        # Always do active observation - agent should always create follow-up thoughts
+        # Force active=True regardless of input
+        params.active = True
+
+        # Get channel ID from params first (if LLM provided it)
+        channel_id = params.channel_id
+
+        # If no channel_id in params, try to get from channel_context
+        if not channel_id:
+            # Get channel context from params or dispatch
+            channel_context: Optional[ChannelContext] = params.channel_context or dispatch_context.channel_context
+
+            # Fallback to thought context if needed
+            if not channel_context and thought.context and hasattr(thought.context, "system_snapshot"):
+                channel_context = thought.context.system_snapshot.channel_context
+
+            # Update params with the resolved channel context
+            if channel_context:
+                params.channel_context = channel_context
+
+            # Extract channel ID for legacy API usage
+            channel_id = extract_channel_id(channel_context)
+            if channel_id and isinstance(channel_id, str) and channel_id.startswith("@"):
+                channel_id = None
+
+        # Use bus manager instead of getting services directly
+        logger.debug("ObserveHandler: Using bus manager for communication and memory operations")
+
+        try:
+            logger.info(f"ObserveHandler: Performing active observation for channel {channel_id}")
+            if not channel_id:
+                raise RuntimeError(f"No channel_id ({channel_id})")
+            messages = await self.bus_manager.communication.fetch_messages(
+                channel_id=str(channel_id).lstrip("#"), limit=ACTIVE_OBSERVE_LIMIT, handler_name=self.__class__.__name__
+            )
+            if messages is None:
+                raise RuntimeError("Failed to fetch messages via multi-service sink")
+            await self._recall_from_messages(channel_id, messages)
+            action_performed = True
+            follow_up_info = f"Fetched {len(messages)} messages from {channel_id}"
+            logger.info(f"ObserveHandler: Active observation complete - {follow_up_info}")
+        except Exception as e:
+            logger.exception(f"ObserveHandler error for {thought_id}: {e}")
+            final_status = ThoughtStatus.FAILED
+            follow_up_info = str(e)
+
+            # Create error follow-up and return immediately to avoid duplicate
+            error_follow_up = f"CIRIS_FOLLOW_UP_THOUGHT: OBSERVE action failed: {follow_up_info}"
+            return self.complete_thought_and_create_followup(
+                thought=thought, follow_up_content=error_follow_up, action_result=result, status=ThoughtStatus.FAILED
+            )
+
+        follow_up_text = (
+            f"CIRIS_FOLLOW_UP_THOUGHT: OBSERVE action completed. Info: {follow_up_info}"
+            if action_performed
+            else f"CIRIS_FOLLOW_UP_THOUGHT: OBSERVE action failed: {follow_up_info}"
+        )
+
+        # Use centralized method to complete thought and create follow-up
+        follow_up_id = self.complete_thought_and_create_followup(
+            thought=thought, follow_up_content=follow_up_text, action_result=result
+        )
+
+        if not follow_up_id:
+            logger.critical(f"Failed to create follow-up for {thought_id}")
+            # NOTE: Audit logging removed - action_dispatcher handles centralized audit logging
+            raise FollowUpCreationError("Failed to create follow-up thought")
+
+        return follow_up_id