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

massgen/frontend/displays/rich_terminal_display.py

@@ -193,6 +193,7 @@ class RichTerminalDisplay(TerminalDisplay):
         self._key_handler = None
         self._input_thread = None
         self._stop_input_thread = False
+        self._user_quit_requested = False  # Flag to signal user wants to quit
         self._original_settings = None
         self._agent_selector_active = False  # Flag to prevent duplicate agent selector calls
 
@@ -207,6 +208,15 @@ class RichTerminalDisplay(TerminalDisplay):
         self._final_presentation_agent = None
         self._final_presentation_vote_results = None
 
+        # Post-evaluation display state
+        self._post_evaluation_active = False
+        self._post_evaluation_content = ""
+        self._post_evaluation_agent = None
+
+        # Restart context state (for attempt 2+)
+        self._restart_context_reason = None
+        self._restart_context_instructions = None
+
         # Code detection patterns
         self.code_patterns = [
             r"```(\w+)?\n(.*?)\n```",  # Markdown code blocks
@@ -1077,12 +1087,25 @@ class RichTerminalDisplay(TerminalDisplay):
                 Layout(footer, name="footer", size=8),
             )
         else:
-            # Arrange layout without final presentation
-            layout.split_column(
-                Layout(header, name="header", size=5),
-                Layout(agent_columns, name="main"),
-                Layout(footer, name="footer", size=8),
-            )
+            # Build layout components
+            layout_components = []
+
+            # Add header
+            layout_components.append(Layout(header, name="header", size=5))
+
+            # Add agent columns
+            layout_components.append(Layout(agent_columns, name="main"))
+
+            # Add post-evaluation panel if active (below agents)
+            post_eval_panel = self._create_post_evaluation_panel()
+            if post_eval_panel:
+                layout_components.append(Layout(post_eval_panel, name="post_eval", size=6))
+
+            # Add footer
+            layout_components.append(Layout(footer, name="footer", size=8))
+
+            # Arrange layout
+            layout.split_column(*layout_components)
 
         return layout
 
@@ -1343,7 +1366,10 @@ class RichTerminalDisplay(TerminalDisplay):
         elif key == "q":
             # Quit the application - restore terminal and stop
             self._stop_input_thread = True
+            self._user_quit_requested = True
             self._restore_terminal_settings()
+            # Print quit message
+            self.console.print("\n[yellow]Exiting coordination...[/yellow]")
 
     def _open_agent_in_default_text_editor(self, agent_id: str) -> None:
         """Open agent's txt file in default text editor."""
@@ -2013,6 +2039,56 @@ class RichTerminalDisplay(TerminalDisplay):
             expand=True,  # Full width
         )
 
+    def _create_post_evaluation_panel(self) -> Optional[Panel]:
+        """Create a panel for post-evaluation display (below agent columns)."""
+        if not self._post_evaluation_active:
+            return None
+
+        content_text = Text()
+
+        if not self._post_evaluation_content:
+            content_text.append("Evaluating answer...", style=self.colors["text"])
+        else:
+            # Show last few lines of post-eval content
+            lines = self._post_evaluation_content.split("\n")
+            display_lines = lines[-5:] if len(lines) > 5 else lines
+
+            for line in display_lines:
+                if line.strip():
+                    formatted_line = self._format_content_line(line)
+                    content_text.append(formatted_line)
+                content_text.append("\n")
+
+        title = f"🔍 Post-Evaluation by {self._post_evaluation_agent}"
+
+        return Panel(
+            content_text,
+            title=f"[{self.colors['info']}]{title}[/{self.colors['info']}]",
+            border_style=self.colors["info"],
+            box=ROUNDED,
+            expand=True,
+            height=6,  # Fixed height to not take too much space
+        )
+
+    def _create_restart_context_panel(self) -> Optional[Panel]:
+        """Create restart context panel for attempt 2+ (yellow warning at top)."""
+        if not self._restart_context_reason or not self._restart_context_instructions:
+            return None
+
+        content_text = Text()
+        content_text.append("Reason: ", style="bold bright_yellow")
+        content_text.append(f"{self._restart_context_reason}\n\n", style="bright_yellow")
+        content_text.append("Instructions: ", style="bold bright_yellow")
+        content_text.append(f"{self._restart_context_instructions}", style="bright_yellow")
+
+        return Panel(
+            content_text,
+            title="[bold bright_yellow]⚠️  PREVIOUS ATTEMPT FEEDBACK[/bold bright_yellow]",
+            border_style="bright_yellow",
+            box=ROUNDED,
+            expand=True,
+        )
+
     def _format_presentation_content(self, content: str) -> Text:
         """Format presentation content with enhanced styling for orchestrator queries."""
         formatted = Text()
@@ -3174,7 +3250,7 @@ class RichTerminalDisplay(TerminalDisplay):
             title="[bold bright_green]🎯 FINAL COORDINATED ANSWER[/bold bright_green]",
             border_style=self.colors["success"],
             box=DOUBLE,
-            expand=False,
+            expand=True,
         )
 
         self.console.print(final_panel)
@@ -3244,10 +3320,80 @@ class RichTerminalDisplay(TerminalDisplay):
                 )
                 self.console.print(error_text)
 
-        # Show interactive options for viewing agent details (only if not in safe mode)
-        if self._keyboard_interactive_mode and hasattr(self, "_agent_keys") and not self._safe_keyboard_mode:
+        # Show interactive options for viewing agent details (only if not in safe mode and not restarting)
+        # Don't show inspection menu if orchestration is restarting
+        is_restarting = hasattr(self, "orchestrator") and hasattr(self.orchestrator, "restart_pending") and self.orchestrator.restart_pending
+        if self._keyboard_interactive_mode and hasattr(self, "_agent_keys") and not self._safe_keyboard_mode and not is_restarting:
             self.show_agent_selector()
 
+    def show_post_evaluation_content(self, content: str, agent_id: str):
+        """Display post-evaluation streaming content in a panel below agents."""
+        self._post_evaluation_active = True
+        self._post_evaluation_agent = agent_id
+        self._post_evaluation_content += content
+        # Panel will be created/updated in _update_display via layout
+
+    def show_restart_banner(self, reason: str, instructions: str, attempt: int, max_attempts: int):
+        """Display restart decision banner prominently (like final presentation)."""
+        # Stop live display temporarily for static banner
+        self.live is not None
+        if self.live:
+            self.live.stop()
+            self.live = None
+
+        # Create restart banner content
+        banner_content = Text()
+        banner_content.append("\nREASON:\n", style="bold bright_yellow")
+        banner_content.append(f"{reason}\n\n", style="bright_yellow")
+        banner_content.append("INSTRUCTIONS FOR NEXT ATTEMPT:\n", style="bold bright_yellow")
+        banner_content.append(f"{instructions}\n", style="bright_yellow")
+
+        restart_panel = Panel(
+            banner_content,
+            title=f"[bold bright_yellow]🔄 ORCHESTRATION RESTART (Attempt {attempt}/{max_attempts})[/bold bright_yellow]",
+            border_style="bright_yellow",
+            box=DOUBLE,
+            expand=True,
+        )
+
+        self.console.print(restart_panel)
+        time.sleep(2.0)  # Allow user to read restart banner
+
+        # Reset state for fresh attempt - clear all agent content and status
+        for agent_id in self.agent_ids:
+            self.agent_outputs[agent_id] = []
+            self.agent_status[agent_id] = "waiting"
+            # Clear text buffers
+            if hasattr(self, "_text_buffers") and agent_id in self._text_buffers:
+                self._text_buffers[agent_id] = ""
+
+        # Clear cached panels and ALL cached state
+        self._agent_panels_cache.clear()
+        self._footer_cache = None
+        self._header_cache = None
+
+        # Clear orchestrator events (from base class)
+        self.orchestrator_events = []
+
+        # Clear presentation state
+        self._final_presentation_active = False
+        self._final_presentation_content = ""
+        self._post_evaluation_active = False
+        self._post_evaluation_content = ""
+
+        # Clear restart context state (so it doesn't show on next attempt)
+        self._restart_context_reason = None
+        self._restart_context_instructions = None
+
+        # DON'T restart live display here - let the next coordinate() call handle it
+        # The CLI will create a fresh UI instance which will initialize its own display
+
+    def show_restart_context_panel(self, reason: str, instructions: str):
+        """Display restart context panel at top of UI (for attempt 2+)."""
+        self._restart_context_reason = reason
+        self._restart_context_instructions = instructions
+        # Panel will be displayed in initialize() method before agent columns
+
     def _display_answer_with_flush(self, answer: str) -> None:
         """Display answer with flush output effect - streaming character by character."""
         import sys

massgen/frontend/displays/simple_display.py

@@ -90,6 +90,27 @@ class SimpleDisplay(BaseDisplay):
             print(f"🗳️ Vote results: {vote_summary}")
         print("=" * 50)
 
+    def show_post_evaluation_content(self, content: str, agent_id: str):
+        """Display post-evaluation streaming content."""
+        print(f"🔍 [{agent_id}] {content}", end="", flush=True)
+
+    def show_restart_banner(self, reason: str, instructions: str, attempt: int, max_attempts: int):
+        """Display restart decision banner."""
+        print("\n" + "🔄" * 40)
+        print(f"ORCHESTRATION RESTART - Attempt {attempt}/{max_attempts}")
+        print("🔄" * 40)
+        print(f"\n{reason}\n")
+        print(f"Instructions: {instructions}\n")
+        print("🔄" * 40 + "\n")
+
+    def show_restart_context_panel(self, reason: str, instructions: str):
+        """Display restart context panel at top of UI (for attempt 2+)."""
+        print("\n" + "⚠️ " * 30)
+        print("PREVIOUS ATTEMPT FEEDBACK")
+        print(f"Reason: {reason}")
+        print(f"Instructions: {instructions}")
+        print("⚠️ " * 30 + "\n")
+
     def cleanup(self):
         """Clean up resources."""
         print(f"\n✅ Coordination completed with {len(self.agent_ids)} agents")

massgen/frontend/displays/terminal_display.py

@@ -220,8 +220,6 @@ class TerminalDisplay(BaseDisplay):
 
         # Add working indicator if transitioning to working
         if old_status != "working" and status == "working":
-            agent_prefix = f"[{agent_id}] " if self.num_agents > 1 else ""
-            print(f"\n{agent_prefix}⚡  Working...")
             if not self.agent_outputs[agent_id] or not self.agent_outputs[agent_id][-1].startswith("⚡"):
                 self.agent_outputs[agent_id].append("⚡  Working...")
 
@@ -245,6 +243,28 @@ class TerminalDisplay(BaseDisplay):
             print(f"🗳️ Vote results: {vote_summary}")
         print("=" * 60)
 
+    def show_post_evaluation_content(self, content: str, agent_id: str):
+        """Display post-evaluation streaming content."""
+        print(f"🔍 Post-Evaluation [{agent_id}]: {content}", end="", flush=True)
+
+    def show_restart_banner(self, reason: str, instructions: str, attempt: int, max_attempts: int):
+        """Display restart decision banner."""
+        print("\n" + "=" * 80)
+        print(f"🔄 ORCHESTRATION RESTART (Attempt {attempt}/{max_attempts})")
+        print("=" * 80)
+        print(f"\nREASON:\n{reason}")
+        print(f"\nINSTRUCTIONS FOR NEXT ATTEMPT:\n{instructions}")
+        print("\n" + "=" * 80 + "\n")
+
+    def show_restart_context_panel(self, reason: str, instructions: str):
+        """Display restart context panel at top of UI (for attempt 2+)."""
+        print("\n" + "⚠" * 40)
+        print("⚠️  PREVIOUS ATTEMPT FEEDBACK")
+        print("⚠" * 40)
+        print(f"\nReason: {reason}")
+        print(f"\nInstructions: {instructions}")
+        print("\n" + "⚠" * 40 + "\n")
+
     def cleanup(self):
         """Clean up display resources."""
         # No special cleanup needed for terminal display

massgen/logger_config.py

@@ -41,6 +41,7 @@ _DEBUG_MODE = False
 _LOG_SESSION_DIR = None
 _LOG_BASE_SESSION_DIR = None  # Base session dir (without turn subdirectory)
 _CURRENT_TURN = None
+_CURRENT_ATTEMPT = None  # Current attempt number for restart tracking
 
 # Console logging suppression (for Rich Live display compatibility)
 _CONSOLE_HANDLER_ID = None
@@ -48,15 +49,15 @@ _CONSOLE_SUPPRESSED = False
 
 
 def get_log_session_dir(turn: Optional[int] = None) -> Path:
-    """Get the current log session directory.
+    """Get the current log session directory, including attempt subdirectory if set.
 
     Args:
         turn: Optional turn number for multi-turn conversations
 
     Returns:
-        Path to the log directory
+        Path to the log directory (includes attempt subdirectory if _CURRENT_ATTEMPT is set)
     """
-    global _LOG_SESSION_DIR, _LOG_BASE_SESSION_DIR, _CURRENT_TURN
+    global _LOG_SESSION_DIR, _LOG_BASE_SESSION_DIR, _CURRENT_TURN, _CURRENT_ATTEMPT
 
     # Initialize base session dir once per session
     if _LOG_BASE_SESSION_DIR is None:
@@ -88,19 +89,62 @@ def get_log_session_dir(turn: Optional[int] = None) -> Path:
         _LOG_SESSION_DIR = None  # Force recreation
 
     if _LOG_SESSION_DIR is None:
-        # Create directory structure based on turn
+        # Build directory structure based on turn and attempt
         if _CURRENT_TURN and _CURRENT_TURN > 0:
             # Multi-turn conversation: organize by turn within session
-            _LOG_SESSION_DIR = _LOG_BASE_SESSION_DIR / f"turn_{_CURRENT_TURN}"
+            base_dir = _LOG_BASE_SESSION_DIR / f"turn_{_CURRENT_TURN}"
         else:
             # First execution or single execution: use base session dir
-            _LOG_SESSION_DIR = _LOG_BASE_SESSION_DIR
+            base_dir = _LOG_BASE_SESSION_DIR
+
+        # Add attempt subdirectory if attempt is set
+        if _CURRENT_ATTEMPT and _CURRENT_ATTEMPT > 0:
+            _LOG_SESSION_DIR = base_dir / f"attempt_{_CURRENT_ATTEMPT}"
+        else:
+            _LOG_SESSION_DIR = base_dir
 
         _LOG_SESSION_DIR.mkdir(parents=True, exist_ok=True)
 
     return _LOG_SESSION_DIR
 
 
+def set_log_attempt(attempt: int) -> None:
+    """Set the current attempt number for restart tracking.
+
+    This forces the log directory to be recreated with the new attempt subdirectory.
+
+    Args:
+        attempt: Attempt number (1-indexed)
+    """
+    global _LOG_SESSION_DIR, _CURRENT_ATTEMPT
+    _CURRENT_ATTEMPT = attempt
+    _LOG_SESSION_DIR = None  # Force recreation with new attempt subdirectory
+
+
+def get_log_session_dir_base() -> Path:
+    """Get the base log session directory without attempt subdirectory.
+
+    This is useful for copying final results to the root level after all attempts complete.
+
+    Returns:
+        Path to the base log directory (turn level or session root, without attempt)
+    """
+    global _LOG_BASE_SESSION_DIR, _CURRENT_TURN
+
+    # Ensure base session dir is initialized
+    if _LOG_BASE_SESSION_DIR is None:
+        # Initialize by calling get_log_session_dir
+        get_log_session_dir()
+
+    # Build base directory based on turn (without attempt)
+    if _CURRENT_TURN and _CURRENT_TURN > 0:
+        # Multi-turn conversation: return turn directory
+        return _LOG_BASE_SESSION_DIR / f"turn_{_CURRENT_TURN}"
+    else:
+        # Single turn: return base session dir
+        return _LOG_BASE_SESSION_DIR
+
+
 def save_execution_metadata(
     query: str,
     config_path: Optional[str] = None,

massgen/message_templates.py

@@ -378,6 +378,93 @@ Present the best possible coordinated answer by combining the strengths from all
         else:
             return presentation_instructions
 
+    def post_evaluation_system_message(
+        self,
+        original_system_message: Optional[str] = None,
+    ) -> str:
+        """System message for post-evaluation phase after final presentation.
+
+        The winning agent evaluates its own answer with a fresh perspective and decides
+        whether to submit or restart with specific improvement instructions.
+
+        Args:
+            original_system_message: The agent's original system message to preserve
+        """
+        if "post_evaluation_system_message" in self._template_overrides:
+            return str(self._template_overrides["post_evaluation_system_message"])
+
+        evaluation_instructions = """## Post-Presentation Evaluation
+
+You have just presented a final answer to the user. Now you must evaluate whether your answer fully addresses the original task.
+
+**Your Task:**
+Review the final answer that was presented and determine if it completely and accurately addresses the original task requirements.
+
+**Available Tools:**
+You have access to the same filesystem and MCP tools that were available during presentation. Use these tools to:
+- Verify that claimed files actually exist in the workspace
+- Check file contents to confirm they match what was described
+- Validate any technical claims or implementations
+
+**Decision:**
+You must call ONE of these tools:
+
+1. **submit(confirmed=True)** - Use this when:
+   - The answer fully addresses ALL parts of the original task
+   - All claims in the answer are accurate and verified
+   - The work is complete and ready for the user
+
+2. **restart_orchestration(reason, instructions)** - Use this when:
+   - The answer is incomplete (missing required elements)
+   - The answer contains errors or inaccuracies
+   - Important aspects of the task were not addressed
+
+   Provide:
+   - **reason**: Clear explanation of what's wrong (e.g., "The task required descriptions of two Beatles, but only John Lennon was described")
+   - **instructions**: Detailed, actionable guidance for the next attempt (e.g.,
+     "Provide two descriptions (John Lennon AND Paul McCartney). Each should include:
+     birth year, role in band, notable songs, impact on music. Use 4-6 sentences per person.")
+
+**Important Notes:**
+- Be honest and thorough in your evaluation
+- You are evaluating your own work with a fresh perspective
+- If you find problems, restarting with clear instructions will lead to a better result
+- The restart process gives you another opportunity to get it right
+"""
+
+        # Combine with original system message if provided
+        if original_system_message:
+            return f"""{original_system_message}
+
+{evaluation_instructions}"""
+        else:
+            return evaluation_instructions
+
+    def format_restart_context(self, reason: str, instructions: str) -> str:
+        """Format restart context for subsequent orchestration attempts.
+
+        This context is added to agent messages (like multi-turn context) on restart attempts.
+
+        Args:
+            reason: Why the previous attempt was insufficient
+            instructions: Detailed guidance for improvement
+        """
+        if "format_restart_context" in self._template_overrides:
+            override = self._template_overrides["format_restart_context"]
+            if callable(override):
+                return override(reason, instructions)
+            return str(override).format(reason=reason, instructions=instructions)
+
+        return f"""<PREVIOUS ATTEMPT FEEDBACK>
+The previous orchestration attempt was restarted because:
+{reason}
+
+**Instructions for this attempt:**
+{instructions}
+
+Please address these specific issues in your coordination and final answer.
+<END OF PREVIOUS ATTEMPT FEEDBACK>"""
+
     # =============================================================================
     # COMPLETE MESSAGE BUILDERS
     # =============================================================================
@@ -509,10 +596,36 @@ Based on the coordination process above, present your final answer:"""
         messages.append({"role": "user", "content": self.enforcement_message()})
         return messages
 
-    def command_execution_system_message(self) -> str:
-        """Generate concise command execution instructions when command line execution is enabled."""
+    def command_execution_system_message(
+        self,
+        docker_mode: bool = False,
+        enable_sudo: bool = False,
+    ) -> str:
+        """Generate concise command execution instructions when command line execution is enabled.
+
+        Args:
+            docker_mode: Whether commands execute in Docker containers
+            enable_sudo: Whether sudo is available in Docker containers
+        """
         parts = ["## Command Execution"]
         parts.append("You can run command line commands using the `execute_command` tool.\n")
+
+        if docker_mode:
+            parts.append("**IMPORTANT: Docker Execution Environment**")
+            parts.append("- You are running in a Linux Docker container (Debian-based)")
+            parts.append("- Base image: Python 3.11-slim with Node.js 20.x")
+            parts.append("- Pre-installed: git, curl, build-essential, pytest, requests, numpy, pandas")
+            parts.append("- Use `apt-get` for system packages (NOT brew, dnf, yum, etc.)")
+
+            if enable_sudo:
+                parts.append("- **Sudo is available**: You can install packages with `sudo apt-get install <package>`")
+                parts.append("- Example: `sudo apt-get update && sudo apt-get install -y ffmpeg`")
+            else:
+                parts.append("- Sudo is NOT available - use pip/npm for user-level packages only")
+                parts.append("- For system packages, ask the user to rebuild the Docker image with needed packages")
+
+            parts.append("")
+
         parts.append("If a `.venv` directory exists in your workspace, it will be automatically used.")
 
         return "\n".join(parts)
@@ -527,6 +640,8 @@ Based on the coordination process above, present your final answer:"""
         enable_image_generation: bool = False,
         agent_answers: Optional[Dict[str, str]] = None,
         enable_command_execution: bool = False,
+        docker_mode: bool = False,
+        enable_sudo: bool = False,
     ) -> str:
         """Generate filesystem access instructions for agents with filesystem support.
 
@@ -539,6 +654,8 @@ Based on the coordination process above, present your final answer:"""
             enable_image_generation: Whether image generation is enabled
             agent_answers: Dict of agent answers (keys are agent IDs) to show workspace structure
             enable_command_execution: Whether command line execution is enabled
+            docker_mode: Whether commands execute in Docker containers
+            enable_sudo: Whether sudo is available in Docker containers
         """
         if "filesystem_system_message" in self._template_overrides:
             return str(self._template_overrides["filesystem_system_message"])
@@ -704,7 +821,10 @@ Based on the coordination process above, present your final answer:"""
 
         # Add command execution instructions if enabled
         if enable_command_execution:
-            command_exec_message = self.command_execution_system_message()
+            command_exec_message = self.command_execution_system_message(
+                docker_mode=docker_mode,
+                enable_sudo=enable_sudo,
+            )
             parts.append(f"\n{command_exec_message}")
 
         return "\n".join(parts)