massgen 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

massgen/orchestrator.py

@@ -44,7 +44,7 @@ from .logger_config import (
 )
 from .message_templates import MessageTemplates
 from .stream_chunk import ChunkType
-from .tool import get_workflow_tools
+from .tool import get_post_evaluation_tools, get_workflow_tools
 from .utils import ActionType, AgentStatus, CoordinationStage
 
 
@@ -164,6 +164,14 @@ class Orchestrator(ChatAgent):
         self.is_orchestrator_timeout: bool = False
         self.timeout_reason: Optional[str] = None
 
+        # Restart feature state tracking
+        self.current_attempt: int = 0
+        max_restarts = self.config.coordination_config.max_orchestration_restarts
+        self.max_attempts: int = 1 + max_restarts
+        self.restart_pending: bool = False
+        self.restart_reason: Optional[str] = None
+        self.restart_instructions: Optional[str] = None
+
         # Coordination state tracking for cleanup
         self._active_streams: Dict = {}
         self._active_tasks: Dict = {}
@@ -264,10 +272,41 @@ class Orchestrator(ChatAgent):
             self.coordination_tracker.initialize_session(list(self.agents.keys()), self.current_task)
             self.workflow_phase = "coordinating"
 
+            # Reset restart_pending flag at start of coordination (will be set again if restart needed)
+            self.restart_pending = False
+
             # Clear agent workspaces for new turn (if this is a multi-turn conversation with history)
             if conversation_context and conversation_context.get("conversation_history"):
                 self._clear_agent_workspaces()
 
+            # Check if planning mode is enabled in config
+            planning_mode_config_exists = (
+                self.config.coordination_config and self.config.coordination_config.enable_planning_mode if self.config and hasattr(self.config, "coordination_config") else False
+            )
+
+            if planning_mode_config_exists:
+                # Analyze question for irreversibility and set planning mode accordingly
+                # This happens silently - users don't see this analysis
+                analysis_result = await self._analyze_question_irreversibility(user_message, conversation_context)
+                has_irreversible = analysis_result["has_irreversible"]
+                blocked_tools = analysis_result["blocked_tools"]
+
+                # Set planning mode and blocked tools for all agents based on analysis
+                for agent_id, agent in self.agents.items():
+                    if hasattr(agent.backend, "set_planning_mode"):
+                        agent.backend.set_planning_mode(has_irreversible)
+                        if hasattr(agent.backend, "set_planning_mode_blocked_tools"):
+                            agent.backend.set_planning_mode_blocked_tools(blocked_tools)
+                        log_orchestrator_activity(
+                            self.orchestrator_id,
+                            f"Set planning mode for {agent_id}",
+                            {
+                                "planning_mode_enabled": has_irreversible,
+                                "blocked_tools_count": len(blocked_tools),
+                                "reason": "irreversibility analysis",
+                            },
+                        )
+
             async for chunk in self._coordinate_agents_with_timeout(conversation_context):
                 yield chunk
 
@@ -336,8 +375,299 @@ class Orchestrator(ChatAgent):
         if log_session_dir:
             self.coordination_tracker.save_coordination_logs(log_session_dir)
 
+    def _format_planning_mode_ui(
+        self,
+        has_irreversible: bool,
+        blocked_tools: set,
+        has_isolated_workspaces: bool,
+        user_question: str,
+    ) -> str:
+        """
+        Format a nice UI box for planning mode status.
+
+        Args:
+            has_irreversible: Whether irreversible operations were detected
+            blocked_tools: Set of specific blocked tool names
+            has_isolated_workspaces: Whether agents have isolated workspaces
+            user_question: The user's question for context
+
+        Returns:
+            Formatted string with nice box UI
+        """
+        if not has_irreversible:
+            # Planning mode disabled - brief message
+            box = "\n╭─ Coordination Mode ────────────────────────────────────────╮\n"
+            box += "│ ✅ Planning Mode: DISABLED                                │\n"
+            box += "│                                                            │\n"
+            box += "│ All tools available during coordination.                  │\n"
+            box += "│ No irreversible operations detected.                      │\n"
+            box += "╰────────────────────────────────────────────────────────────╯\n"
+            return box
+
+        # Planning mode enabled
+        box = "\n╭─ Coordination Mode ────────────────────────────────────────╮\n"
+        box += "│ 🧠 Planning Mode: ENABLED                                  │\n"
+        box += "│                                                            │\n"
+
+        if has_isolated_workspaces:
+            box += "│ 🔒 Workspace: Isolated (filesystem ops allowed)           │\n"
+            box += "│                                                            │\n"
+
+        # Description
+        box += "│ Agents will plan and coordinate without executing         │\n"
+        box += "│ irreversible actions. The winning agent will implement    │\n"
+        box += "│ the plan during final presentation.                       │\n"
+        box += "│                                                            │\n"
+
+        # Blocked tools section
+        if blocked_tools:
+            box += "│ 🚫 Blocked Tools:                                          │\n"
+            # Format tools into nice columns
+            sorted_tools = sorted(blocked_tools)
+            for i, tool in enumerate(sorted_tools[:5], 1):  # Show max 5 tools
+                # Shorten tool name if too long
+                display_tool = tool if len(tool) <= 50 else tool[:47] + "..."
+                box += f"│   {i}. {display_tool:<54} │\n"
+
+            if len(sorted_tools) > 5:
+                remaining = len(sorted_tools) - 5
+                box += f"│   ... and {remaining} more tool(s)                              │\n"
+            box += "│                                                            │\n"
+        else:
+            box += "│ 🚫 Blocking: ALL MCP tools                                 │\n"
+            box += "│                                                            │\n"
+
+        # Add brief analysis summary
+        box += "│ 📊 Analysis:                                               │\n"
+        # Create a brief summary from the question
+        summary = user_question[:50] + "..." if len(user_question) > 50 else user_question
+        # Wrap text to fit in box
+        words = summary.split()
+        line = "│   "
+        for word in words:
+            if len(line) + len(word) + 1 > 60:
+                box += line.ljust(61) + "│\n"
+                line = "│   " + word + " "
+            else:
+                line += word + " "
+        if len(line) > 4:  # If there's content
+            box += line.ljust(61) + "│\n"
+
+        box += "╰────────────────────────────────────────────────────────────╯\n"
+        return box
+
+    async def _analyze_question_irreversibility(self, user_question: str, conversation_context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Analyze if the user's question involves MCP tools with irreversible outcomes.
+
+        This method randomly selects an available agent to analyze whether executing
+        the user's question would involve MCP tool operations with irreversible outcomes
+        (e.g., sending Discord messages, posting tweets, deleting files) vs reversible
+        read operations (e.g., reading Discord messages, searching tweets, listing files).
+
+        Args:
+            user_question: The user's question/request
+            conversation_context: Full conversation context including history
+
+        Returns:
+            Dict with:
+                - has_irreversible (bool): True if irreversible operations detected
+                - blocked_tools (set): Set of MCP tool names to block (e.g., {'mcp__discord__discord_send'})
+                                      Empty set means block ALL MCP tools
+        """
+        import random
+
+        print("=" * 80, flush=True)
+        print("🔍 [INTELLIGENT PLANNING MODE] Analyzing question for irreversibility...", flush=True)
+        print(f"📝 Question: {user_question[:100]}{'...' if len(user_question) > 100 else ''}", flush=True)
+        print("=" * 80, flush=True)
+
+        # Select a random agent for analysis
+        available_agents = [aid for aid, agent in self.agents.items() if agent.backend is not None]
+        if not available_agents:
+            # No agents available, default to safe mode (planning enabled, block ALL)
+            log_orchestrator_activity(
+                self.orchestrator_id,
+                "No agents available for irreversibility analysis, defaulting to planning mode",
+                {},
+            )
+            return {"has_irreversible": True, "blocked_tools": set()}
+
+        analyzer_agent_id = random.choice(available_agents)
+        analyzer_agent = self.agents[analyzer_agent_id]
+
+        print(f"🤖 Selected analyzer agent: {analyzer_agent_id}", flush=True)
+
+        # Check if agents have isolated workspaces
+        has_isolated_workspaces = False
+        workspace_info = []
+        for agent_id, agent in self.agents.items():
+            if agent.backend and agent.backend.filesystem_manager:
+                cwd = agent.backend.filesystem_manager.cwd
+                if cwd and "workspace" in os.path.basename(cwd).lower():
+                    has_isolated_workspaces = True
+                    workspace_info.append(f"{agent_id}: {cwd}")
+
+        if has_isolated_workspaces:
+            print("🔒 Detected isolated agent workspaces - filesystem ops will be allowed", flush=True)
+
+        log_orchestrator_activity(
+            self.orchestrator_id,
+            "Analyzing question irreversibility",
+            {
+                "analyzer_agent": analyzer_agent_id,
+                "question_preview": user_question[:100] + "..." if len(user_question) > 100 else user_question,
+                "has_isolated_workspaces": has_isolated_workspaces,
+            },
+        )
+
+        # Build analysis prompt - now asking for specific tool names
+        workspace_context = ""
+        if has_isolated_workspaces:
+            workspace_context = """
+IMPORTANT - ISOLATED WORKSPACES:
+The agents are working in isolated temporary workspaces (directories containing "workspace" in their name).
+Filesystem operations (read_file, write_file, delete_file, list_files, etc.) within these isolated workspaces are SAFE and REVERSIBLE.
+They should NOT be blocked because:
+- These are temporary directories specific to this coordination session
+- Files created/modified are isolated from external systems
+- Changes are contained within the agent's sandbox
+- The workspace can be cleared after coordination
+
+Only block filesystem operations if they explicitly target paths OUTSIDE the isolated workspace.
+"""
+
+        analysis_prompt = f"""You are analyzing whether a user's request involves operations with irreversible outcomes.
+
+USER REQUEST:
+{user_question}
+{workspace_context}
+CONTEXT:
+Your task is to determine if executing this request would involve MCP (Model Context Protocol) tools that have irreversible outcomes, and if so, identify which specific tools should be blocked.
+
+MCP tools follow the naming convention: mcp__<server>__<tool_name>
+Examples:
+- mcp__discord__discord_send (irreversible - sends messages)
+- mcp__discord__discord_read_channel (reversible - reads messages)
+- mcp__twitter__post_tweet (irreversible - posts publicly)
+- mcp__twitter__search_tweets (reversible - searches)
+- mcp__filesystem__write_file (SAFE in isolated workspace - writes to temporary files)
+- mcp__filesystem__read_file (reversible - reads files)
+
+IRREVERSIBLE OPERATIONS:
+- Sending messages (discord_send, slack_send, etc.)
+- Posting content publicly (post_tweet, create_post, etc.)
+- Deleting files or data OUTSIDE isolated workspace (delete_file on external paths, remove_data, etc.)
+- Modifying external systems (write_file to external paths, update_record, etc.)
+- Creating permanent records (create_issue, add_comment, etc.)
+- Executing commands that change state (run_command, execute_script, etc.)
+
+REVERSIBLE OPERATIONS (DO NOT BLOCK):
+- Reading messages or data (read_channel, get_messages, etc.)
+- Searching or querying information (search_tweets, query_data, etc.)
+- Listing files or resources (list_files, list_channels, etc.)
+- Fetching data from APIs (get_user, fetch_data, etc.)
+- Viewing information (view_channel, get_info, etc.)
+- Filesystem operations IN ISOLATED WORKSPACE (write_file, read_file, delete_file, list_files when in workspace*)
+
+Respond in this EXACT format:
+IRREVERSIBLE: YES/NO
+BLOCKED_TOOLS: tool1, tool2, tool3
+
+If IRREVERSIBLE is NO, leave BLOCKED_TOOLS empty.
+If IRREVERSIBLE is YES, list the specific MCP tool names that should be blocked (e.g., mcp__discord__discord_send).
+
+Your answer:"""
+
+        # Create messages for the analyzer
+        analysis_messages = [
+            {"role": "user", "content": analysis_prompt},
+        ]
+
+        try:
+            # Stream response from analyzer agent (but don't show to user)
+            response_text = ""
+            async for chunk in analyzer_agent.backend.stream_with_tools(
+                messages=analysis_messages,
+                tools=[],  # No tools needed for simple analysis
+                agent_id=analyzer_agent_id,
+            ):
+                if chunk.type == "content" and chunk.content:
+                    response_text += chunk.content
+
+            # Parse response
+            response_clean = response_text.strip()
+            has_irreversible = False
+            blocked_tools = set()
+
+            # Parse IRREVERSIBLE line
+            found_irreversible_line = False
+            for line in response_clean.split("\n"):
+                line = line.strip()
+                if line.startswith("IRREVERSIBLE:"):
+                    found_irreversible_line = True
+                    # Extract the value after the colon
+                    value = line.split(":", 1)[1].strip().upper()
+                    # Check if the first word is YES
+                    has_irreversible = value.startswith("YES")
+                elif line.startswith("BLOCKED_TOOLS:"):
+                    # Extract tool names after the colon
+                    tools_part = line.split(":", 1)[1].strip()
+                    if tools_part:
+                        # Split by comma and clean up whitespace
+                        blocked_tools = {tool.strip() for tool in tools_part.split(",") if tool.strip()}
+
+            # Fallback: If no structured format found, look for YES/NO in the response
+            if not found_irreversible_line:
+                print("⚠️  [WARNING] No 'IRREVERSIBLE:' line found, using fallback parsing", flush=True)
+                response_upper = response_clean.upper()
+                # Look for clear YES/NO indicators
+                if "YES" in response_upper and "NO" not in response_upper:
+                    has_irreversible = True
+                elif "NO" in response_upper:
+                    has_irreversible = False
+                else:
+                    # Default to safe mode if unclear
+                    has_irreversible = True
+
+            log_orchestrator_activity(
+                self.orchestrator_id,
+                "Irreversibility analysis complete",
+                {
+                    "analyzer_agent": analyzer_agent_id,
+                    "response": response_clean[:100],
+                    "has_irreversible": has_irreversible,
+                    "blocked_tools_count": len(blocked_tools),
+                },
+            )
+
+            # Display nice UI box for planning mode status
+            ui_box = self._format_planning_mode_ui(
+                has_irreversible=has_irreversible,
+                blocked_tools=blocked_tools,
+                has_isolated_workspaces=has_isolated_workspaces,
+                user_question=user_question,
+            )
+            print(ui_box, flush=True)
+
+            return {"has_irreversible": has_irreversible, "blocked_tools": blocked_tools}
+
+        except Exception as e:
+            # On error, default to safe mode (planning enabled, block ALL)
+            log_orchestrator_activity(
+                self.orchestrator_id,
+                "Irreversibility analysis failed, defaulting to planning mode",
+                {"error": str(e)},
+            )
+            return {"has_irreversible": True, "blocked_tools": set()}
+
     async def _coordinate_agents_with_timeout(self, conversation_context: Optional[Dict[str, Any]] = None) -> AsyncGenerator[StreamChunk, None]:
-        """Execute coordination with orchestrator-level timeout protection."""
+        """Execute coordination with orchestrator-level timeout protection.
+
+        When restart is needed, this method completes and returns control to CLI,
+        which will call coordinate() again (similar to multiturn pattern).
+        """
+        # Reset timing and state for this attempt
         self.coordination_start_time = time.time()
         self.total_tokens = 0
         self.is_orchestrator_timeout = False
@@ -345,13 +675,19 @@ class Orchestrator(ChatAgent):
 
         log_orchestrator_activity(
             self.orchestrator_id,
-            "Starting coordination with timeout",
+            f"Starting coordination attempt {self.current_attempt + 1}/{self.max_attempts}",
             {
                 "timeout_seconds": self.config.timeout_config.orchestrator_timeout_seconds,
                 "agents": list(self.agents.keys()),
+                "has_restart_context": bool(self.restart_reason),
             },
         )
 
+        # Set log attempt for directory organization
+        from massgen.logger_config import set_log_attempt
+
+        set_log_attempt(self.current_attempt + 1)
+
         # Track active coordination state for cleanup
         self._active_streams = {}
         self._active_tasks = {}
@@ -385,6 +721,8 @@ class Orchestrator(ChatAgent):
             async for chunk in self._handle_orchestrator_timeout():
                 yield chunk
 
+        # Exit here - if restart is needed, CLI will call coordinate() again
+
     async def _coordinate_agents(self, conversation_context: Optional[Dict[str, Any]] = None) -> AsyncGenerator[StreamChunk, None]:
         """Execute unified MassGen coordination workflow with real-time streaming."""
         log_coordination_step(
@@ -1352,10 +1690,16 @@ class Orchestrator(ChatAgent):
 
                 # Extract command execution parameters
                 enable_command_execution = False
+                docker_mode = False
+                enable_sudo = False
                 if hasattr(agent, "config") and agent.config:
                     enable_command_execution = agent.config.backend_params.get("enable_mcp_command_line", False)
+                    docker_mode = agent.config.backend_params.get("command_line_execution_mode", "local") == "docker"
+                    enable_sudo = agent.config.backend_params.get("command_line_docker_enable_sudo", False)
                 elif hasattr(agent, "backend") and hasattr(agent.backend, "backend_params"):
                     enable_command_execution = agent.backend.backend_params.get("enable_mcp_command_line", False)
+                    docker_mode = agent.backend.backend_params.get("command_line_execution_mode", "local") == "docker"
+                    enable_sudo = agent.backend.backend_params.get("command_line_docker_enable_sudo", False)
 
                 filesystem_system_message = self.message_templates.filesystem_system_message(
                     main_workspace=main_workspace,
@@ -1366,6 +1710,8 @@ class Orchestrator(ChatAgent):
                     enable_image_generation=enable_image_generation,
                     agent_answers=answers,
                     enable_command_execution=enable_command_execution,
+                    docker_mode=docker_mode,
+                    enable_sudo=enable_sudo,
                 )
                 agent_system_message = f"{agent_system_message}\n\n{filesystem_system_message}" if agent_system_message else filesystem_system_message
 
@@ -1379,17 +1725,17 @@ class Orchestrator(ChatAgent):
                 logger.info(f"[Orchestrator] Agent {agent_id} sees no existing answers")
 
             # Check if planning mode is enabled for coordination phase
+            # Use the ACTUAL backend planning mode status (set by intelligent analysis)
+            # instead of the static config setting
             is_coordination_phase = self.workflow_phase == "coordinating"
-            planning_mode_enabled = (
-                self.config.coordination_config and self.config.coordination_config.enable_planning_mode and is_coordination_phase
-                if self.config and hasattr(self.config, "coordination_config")
-                else False
-            )
+            planning_mode_enabled = agent.backend.is_planning_mode_enabled() if is_coordination_phase else False
 
             # Add planning mode instructions to system message if enabled
-            if planning_mode_enabled and self.config.coordination_config.planning_mode_instruction:
+            # Only add instructions if we have a coordination config with planning instruction
+            if planning_mode_enabled and self.config and hasattr(self.config, "coordination_config") and self.config.coordination_config and self.config.coordination_config.planning_mode_instruction:
                 planning_instructions = f"\n\n{self.config.coordination_config.planning_mode_instruction}"
                 agent_system_message = f"{agent_system_message}{planning_instructions}" if agent_system_message else planning_instructions.strip()
+                print(f"📝 [{agent_id}] Adding planning mode instructions to system message", flush=True)
 
             # Build conversation with context support
             if conversation_context and conversation_context.get("conversation_history"):
@@ -1410,6 +1756,15 @@ class Orchestrator(ChatAgent):
                     base_system_message=agent_system_message,
                 )
 
+            # Inject restart context if this is a restart attempt (like multi-turn context)
+            if self.restart_reason and self.restart_instructions:
+                restart_context = self.message_templates.format_restart_context(
+                    self.restart_reason,
+                    self.restart_instructions,
+                )
+                # Prepend restart context to user message
+                conversation["user_message"] = restart_context + "\n\n" + conversation["user_message"]
+
             # Track all the context used for this agent execution
             self.coordination_tracker.track_agent_context(
                 agent_id,
@@ -1891,48 +2246,81 @@ class Orchestrator(ChatAgent):
             return ("error", str(e))
 
     async def _present_final_answer(self) -> AsyncGenerator[StreamChunk, None]:
-        """Present the final coordinated answer."""
-        log_stream_chunk("orchestrator", "content", "## 🎯 Final Coordinated Answer\n")
-        yield StreamChunk(type="content", content="## 🎯 Final Coordinated Answer\n")
+        """Present the final coordinated answer with optional post-evaluation and restart loop."""
 
         # Select the best agent based on current state
         if not self._selected_agent:
             self._selected_agent = self._determine_final_agent_from_states()
-            if self._selected_agent:
-                log_stream_chunk(
-                    "orchestrator",
-                    "content",
-                    f"🏆 Selected Agent: {self._selected_agent}\n",
-                )
-                yield StreamChunk(
-                    type="content",
-                    content=f"🏆 Selected Agent: {self._selected_agent}\n",
-                )
-
-        if self._selected_agent and self._selected_agent in self.agent_states and self.agent_states[self._selected_agent].answer:
-            final_answer = self.agent_states[self._selected_agent].answer  # NOTE: This is the raw answer from the winning agent, not the actual final answer.
-
-            # Add to conversation history
-            self.add_to_history("assistant", final_answer)
 
-            log_stream_chunk("orchestrator", "content", f"🏆 Selected Agent: {self._selected_agent}\n")
-            yield StreamChunk(type="content", content=f"🏆 Selected Agent: {self._selected_agent}\n")
-            log_stream_chunk("orchestrator", "content", final_answer)
-            yield StreamChunk(type="content", content=final_answer)
-            log_stream_chunk(
-                "orchestrator",
-                "content",
-                f"\n\n---\n*Coordinated by {len(self.agents)} agents via MassGen framework*",
-            )
-            yield StreamChunk(
-                type="content",
-                content=f"\n\n---\n*Coordinated by {len(self.agents)} agents via MassGen framework*",
-            )
-        else:
+        if not self._selected_agent:
             error_msg = "❌ Unable to provide coordinated answer - no successful agents"
             self.add_to_history("assistant", error_msg)
             log_stream_chunk("orchestrator", "error", error_msg)
             yield StreamChunk(type="content", content=error_msg)
+            self.workflow_phase = "presenting"
+            log_stream_chunk("orchestrator", "done", None)
+            yield StreamChunk(type="done")
+            return
+
+        # Get vote results for presentation
+        vote_results = self._get_vote_results()
+
+        log_stream_chunk("orchestrator", "content", "## 🎯 Final Coordinated Answer\n")
+        yield StreamChunk(type="content", content="## 🎯 Final Coordinated Answer\n")
+
+        # Stream final presentation from winning agent
+        log_stream_chunk("orchestrator", "content", f"🏆 Selected Agent: {self._selected_agent}\n")
+        yield StreamChunk(type="content", content=f"🏆 Selected Agent: {self._selected_agent}\n")
+
+        # Stream the final presentation (with full tool support)
+        presentation_content = ""
+        async for chunk in self.get_final_presentation(self._selected_agent, vote_results):
+            if chunk.type == "content" and chunk.content:
+                presentation_content += chunk.content
+            yield chunk
+
+        # Check if post-evaluation should run
+        # Skip post-evaluation on final attempt (user clarification #4)
+        is_final_attempt = self.current_attempt >= (self.max_attempts - 1)
+        should_evaluate = self.max_attempts > 1 and not is_final_attempt
+
+        if should_evaluate:
+            # Run post-evaluation
+            final_answer_to_evaluate = self._final_presentation_content or presentation_content
+            async for chunk in self.post_evaluate_answer(self._selected_agent, final_answer_to_evaluate):
+                yield chunk
+
+            # Check if restart was requested
+            if self.restart_pending and self.current_attempt < (self.max_attempts - 1):
+                # Show restart banner
+                restart_banner = f"""
+
+🔄 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   ORCHESTRATION RESTART (Attempt {self.current_attempt + 2}/{self.max_attempts})
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+REASON:
+{self.restart_reason}
+
+INSTRUCTIONS FOR NEXT ATTEMPT:
+{self.restart_instructions}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+"""
+                log_stream_chunk("orchestrator", "status", restart_banner)
+                yield StreamChunk(type="restart_banner", content=restart_banner, source="orchestrator")
+
+                # Reset state for restart (prepare for next coordinate() call)
+                self.handle_restart()
+
+                # Don't add to history or set workflow phase - restart is pending
+                # Exit here - CLI will detect restart_pending and call coordinate() again
+                return
+
+        # No restart - add final answer to conversation history
+        if self._final_presentation_content:
+            self.add_to_history("assistant", self._final_presentation_content)
 
         # Update workflow phase
         self.workflow_phase = "presenting"
@@ -2108,10 +2496,16 @@ class Orchestrator(ChatAgent):
 
         # Extract command execution parameters
         enable_command_execution = False
+        docker_mode = False
+        enable_sudo = False
         if hasattr(agent, "config") and agent.config:
             enable_command_execution = agent.config.backend_params.get("enable_mcp_command_line", False)
+            docker_mode = agent.config.backend_params.get("command_line_execution_mode", "local") == "docker"
+            enable_sudo = agent.config.backend_params.get("command_line_docker_enable_sudo", False)
         elif hasattr(agent, "backend") and hasattr(agent.backend, "backend_params"):
             enable_command_execution = agent.backend.backend_params.get("enable_mcp_command_line", False)
+            docker_mode = agent.backend.backend_params.get("command_line_execution_mode", "local") == "docker"
+            enable_sudo = agent.backend.backend_params.get("command_line_docker_enable_sudo", False)
         # Check if audio generation is enabled for this agent
         enable_audio_generation = False
         if hasattr(agent, "config") and agent.config:
@@ -2169,6 +2563,8 @@ class Orchestrator(ChatAgent):
                     enable_image_generation=enable_image_generation,
                     agent_answers=all_answers,
                     enable_command_execution=enable_command_execution,
+                    docker_mode=docker_mode,
+                    enable_sudo=enable_sudo,
                 )
                 + "\n\n## Instructions\n"
                 + base_system_message
@@ -2360,6 +2756,204 @@ class Orchestrator(ChatAgent):
             # Save logs
             self.save_coordination_logs()
 
+        # Don't yield done here - let _present_final_answer handle final done after post-evaluation
+
+    async def post_evaluate_answer(self, selected_agent_id: str, final_answer: str) -> AsyncGenerator[StreamChunk, None]:
+        """Post-evaluation phase where winning agent evaluates its own answer.
+
+        The agent reviews the final answer and decides whether to submit or restart
+        with specific improvement instructions.
+
+        Args:
+            selected_agent_id: The agent that won the vote and presented the answer
+            final_answer: The final answer that was presented
+
+        Yields:
+            StreamChunk: Stream chunks from the evaluation process
+        """
+        if selected_agent_id not in self.agents:
+            log_stream_chunk("orchestrator", "error", f"Selected agent {selected_agent_id} not found for post-evaluation")
+            yield StreamChunk(type="error", error=f"Selected agent {selected_agent_id} not found")
+            return
+
+        agent = self.agents[selected_agent_id]
+
+        # Use debug override on first attempt if configured
+        eval_answer = final_answer
+        if self.config.debug_final_answer and self.current_attempt == 0:
+            eval_answer = self.config.debug_final_answer
+            log_stream_chunk("orchestrator", "debug", f"Using debug override for post-evaluation: {self.config.debug_final_answer}")
+            yield StreamChunk(
+                type="debug",
+                content=f"[DEBUG MODE] Overriding answer for evaluation: {self.config.debug_final_answer}",
+                source="orchestrator",
+            )
+
+        # Build evaluation message
+        evaluation_content = f"""{self.message_templates.format_original_message(self.current_task or "Task")}
+
+FINAL ANSWER TO EVALUATE:
+{eval_answer}
+
+Review this answer carefully and determine if it fully addresses the original task. Use your available tools to verify claims and check files as needed.
+Then call either submit(confirmed=True) if the answer is satisfactory, or restart_orchestration(reason, instructions) if improvements are needed."""
+
+        # Get agent's configurable system message
+        agent_system_message = agent.get_configurable_system_message()
+
+        # Build post-evaluation system message
+        base_system_message = self.message_templates.post_evaluation_system_message(agent_system_message)
+
+        # Add filesystem context if available (same as final presentation)
+        if agent.backend.filesystem_manager:
+            main_workspace = str(agent.backend.filesystem_manager.get_current_workspace())
+            temp_workspace = str(agent.backend.filesystem_manager.agent_temporary_workspace) if agent.backend.filesystem_manager.agent_temporary_workspace else None
+            context_paths = agent.backend.filesystem_manager.path_permission_manager.get_context_paths() if agent.backend.filesystem_manager.path_permission_manager else []
+            previous_turns_context = self._get_previous_turns_context_paths()
+            current_turn_num = len(previous_turns_context) + 1 if previous_turns_context else 1
+            turns_to_show = [t for t in previous_turns_context if t["turn"] < current_turn_num - 1]
+            workspace_prepopulated = len(previous_turns_context) > 0
+
+            # Get all answers for context
+            all_answers = {aid: s.answer for aid, s in self.agent_states.items() if s.answer}
+
+            base_system_message = (
+                self.message_templates.filesystem_system_message(
+                    main_workspace=main_workspace,
+                    temp_workspace=temp_workspace,
+                    context_paths=context_paths,
+                    previous_turns=turns_to_show,
+                    workspace_prepopulated=workspace_prepopulated,
+                    enable_image_generation=False,
+                    agent_answers=all_answers,
+                    enable_command_execution=False,
+                    docker_mode=False,
+                    enable_sudo=False,
+                )
+                + "\n\n## Post-Evaluation Task\n"
+                + base_system_message
+            )
+
+        # Create evaluation messages
+        evaluation_messages = [
+            {"role": "system", "content": base_system_message},
+            {"role": "user", "content": evaluation_content},
+        ]
+
+        # Get post-evaluation tools
+        api_format = "chat_completions"  # Default format
+        if hasattr(agent.backend, "api_format"):
+            api_format = agent.backend.api_format
+        post_eval_tools = get_post_evaluation_tools(api_format=api_format)
+
+        log_stream_chunk("orchestrator", "status", "🔍 Post-evaluation: Reviewing final answer\n")
+        yield StreamChunk(type="status", content="🔍 Post-evaluation: Reviewing final answer\n", source="orchestrator")
+
+        # Stream evaluation with tools (with timeout protection)
+        evaluation_complete = False
+        tool_call_detected = False
+
+        try:
+            timeout_seconds = self.config.timeout_config.orchestrator_timeout_seconds
+            async with asyncio.timeout(timeout_seconds):
+                async for chunk in agent.chat(messages=evaluation_messages, tools=post_eval_tools, reset_chat=True, current_stage=CoordinationStage.POST_EVALUATION):
+                    chunk_type = self._get_chunk_type_value(chunk)
+
+                    if chunk_type == "content" and chunk.content:
+                        log_stream_chunk("orchestrator", "content", chunk.content, selected_agent_id)
+                        yield StreamChunk(type="content", content=chunk.content, source=selected_agent_id)
+                    elif chunk_type in ["reasoning", "reasoning_done", "reasoning_summary", "reasoning_summary_done"]:
+                        reasoning_chunk = StreamChunk(
+                            type=chunk_type,
+                            content=chunk.content,
+                            source=selected_agent_id,
+                            reasoning_delta=getattr(chunk, "reasoning_delta", None),
+                            reasoning_text=getattr(chunk, "reasoning_text", None),
+                            reasoning_summary_delta=getattr(chunk, "reasoning_summary_delta", None),
+                            reasoning_summary_text=getattr(chunk, "reasoning_summary_text", None),
+                            item_id=getattr(chunk, "item_id", None),
+                            content_index=getattr(chunk, "content_index", None),
+                            summary_index=getattr(chunk, "summary_index", None),
+                        )
+                        log_stream_chunk("orchestrator", chunk.type, chunk.content, selected_agent_id)
+                        yield reasoning_chunk
+                    elif chunk_type == "tool_calls":
+                        # Post-evaluation tool call detected
+                        tool_call_detected = True
+                        if hasattr(chunk, "tool_calls") and chunk.tool_calls:
+                            for tool_call in chunk.tool_calls:
+                                # Use backend's tool extraction (same as regular coordination)
+                                tool_name = agent.backend.extract_tool_name(tool_call)
+                                tool_args = agent.backend.extract_tool_arguments(tool_call)
+
+                                if tool_name == "submit":
+                                    log_stream_chunk("orchestrator", "status", "✅ Evaluation complete - answer approved\n")
+                                    yield StreamChunk(type="status", content="✅ Evaluation complete - answer approved\n", source="orchestrator")
+                                    evaluation_complete = True
+                                elif tool_name == "restart_orchestration":
+                                    # Parse restart parameters from extracted args
+                                    self.restart_reason = tool_args.get("reason", "No reason provided")
+                                    self.restart_instructions = tool_args.get("instructions", "No instructions provided")
+                                    self.restart_pending = True
+
+                                    log_stream_chunk("orchestrator", "status", "🔄 Restart requested\n")
+                                    yield StreamChunk(type="status", content="🔄 Restart requested\n", source="orchestrator")
+                                    evaluation_complete = True
+                    elif chunk_type == "done":
+                        log_stream_chunk("orchestrator", "done", None, selected_agent_id)
+                        yield StreamChunk(type="done", source=selected_agent_id)
+                    elif chunk_type == "error":
+                        log_stream_chunk("orchestrator", "error", chunk.error, selected_agent_id)
+                        yield StreamChunk(type="error", error=chunk.error, source=selected_agent_id)
+                    else:
+                        # Pass through other chunk types
+                        log_stream_chunk("orchestrator", chunk_type, getattr(chunk, "content", ""), selected_agent_id)
+                        yield StreamChunk(
+                            type=chunk_type,
+                            content=getattr(chunk, "content", ""),
+                            source=selected_agent_id,
+                            **{k: v for k, v in chunk.__dict__.items() if k not in ["type", "content", "source", "timestamp", "sequence_number"]},
+                        )
+        except asyncio.TimeoutError:
+            log_stream_chunk("orchestrator", "status", "⏱️ Post-evaluation timed out - auto-submitting answer\n")
+            yield StreamChunk(type="status", content="⏱️ Post-evaluation timed out - auto-submitting answer\n", source="orchestrator")
+            evaluation_complete = True
+            # Don't set restart_pending - let it default to False (auto-submit)
+        finally:
+            # If no tool was called and evaluation didn't complete, auto-submit
+            if not evaluation_complete and not tool_call_detected:
+                log_stream_chunk("orchestrator", "status", "✅ Auto-submitting answer (no tool call detected)\n")
+                yield StreamChunk(type="status", content="✅ Auto-submitting answer (no tool call detected)\n", source="orchestrator")
+
+    def handle_restart(self):
+        """Reset orchestration state for restart attempt.
+
+        Clears agent states and coordination messages while preserving
+        restart reason and instructions for the next attempt.
+        """
+        log_orchestrator_activity("handle_restart", f"Resetting state for restart attempt {self.current_attempt + 1}")
+
+        # Reset agent states
+        for agent_id in self.agent_states:
+            self.agent_states[agent_id] = AgentState()
+
+        # Clear coordination messages
+        self._coordination_messages = []
+        self._selected_agent = None
+        self._final_presentation_content = None
+
+        # Reset coordination tracker for new attempt
+        self.coordination_tracker = CoordinationTracker()
+        self.coordination_tracker.initialize_session(list(self.agents.keys()))
+
+        # Reset workflow phase to idle so next coordinate() call starts fresh
+        self.workflow_phase = "idle"
+
+        # Increment attempt counter
+        self.current_attempt += 1
+
+        log_orchestrator_activity("handle_restart", f"State reset complete - starting attempt {self.current_attempt + 1}")
+
     def _get_vote_results(self) -> Dict[str, Any]:
         """Get current vote results and statistics."""
         agent_answers = {aid: state.answer for aid, state in self.agent_states.items() if state.answer}
@@ -2428,6 +3022,19 @@ class Orchestrator(ChatAgent):
 
     async def _handle_followup(self, user_message: str, conversation_context: Optional[Dict[str, Any]] = None) -> AsyncGenerator[StreamChunk, None]:
         """Handle follow-up questions after presenting final answer with conversation context."""
+        # Analyze the follow-up question for irreversibility before re-coordinating
+        has_irreversible = await self._analyze_question_irreversibility(user_message, conversation_context or {})
+
+        # Set planning mode for all agents based on analysis
+        for agent_id, agent in self.agents.items():
+            if hasattr(agent.backend, "set_planning_mode"):
+                agent.backend.set_planning_mode(has_irreversible)
+                log_orchestrator_activity(
+                    self.orchestrator_id,
+                    f"Set planning mode for {agent_id} (follow-up)",
+                    {"planning_mode_enabled": has_irreversible, "reason": "follow-up irreversibility analysis"},
+                )
+
         # For now, acknowledge with context awareness
         # Future: implement full re-coordination with follow-up context
 
@@ -2540,8 +3147,9 @@ class Orchestrator(ChatAgent):
         """
         if self.config and hasattr(self.config, "get_configurable_system_message"):
             return self.config.get_configurable_system_message()
-        elif self.config and hasattr(self.config, "custom_system_instruction"):
-            return self.config.custom_system_instruction
+        elif self.config and hasattr(self.config, "_custom_system_instruction"):
+            # Access private attribute to avoid deprecation warning
+            return self.config._custom_system_instruction
         elif self.config and self.config.backend_params:
             # Check for backend-specific system prompts
             backend_params = self.config.backend_params