massgen 0.1.2__py3-none-any.whl → 0.1.4__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,