Refactor UI handling and improve error reporting in SetupAgent

- Enhanced UIManager integration in SetupAgent to ensure proper display of final summaries and error states.
- Added checks to prevent re-displaying summaries on early exits.
- Improved error handling during task execution, ensuring critical errors are reported to the console.
- Updated HTML and JavaScript for architecture tabs to enhance user interaction and maintain active state across tab switches.

Author: Codegass

agent/agent.py

@@ -243,21 +243,25 @@ def setup_project(
         cmd_logger, cmd_logger_id = create_command_logger("project", project_name)
         cmd_logger.info(f"Starting project setup: {project_name} (docker_label={docker_label})")
 
-        # Initialize UI Manager if in UI mode
-        if self.config.ui_mode:
-            self.ui_manager = UIManager(project_name=project_name, console=self.console)
-            self.ui_manager.start()
-        else:
-            self.console.print(
-                Panel.fit(
-                    f"[bold blue]Setting up project: {project_name}[/bold blue]\n"
-                    f"[dim]Repository: {project_url}[/dim]\n"
-                    f"[dim]Goal: {goal}[/dim]",
-                    border_style="blue",
-                )
-            )
+        # Track whether we already displayed the final UI summary so the
+        # cleanup `finally` below doesn't re-display or skip it incorrectly.
+        final_summary_shown = False
 
         try:
+            # Initialize UI Manager if in UI mode
+            if self.config.ui_mode:
+                self.ui_manager = UIManager(project_name=project_name, console=self.console)
+                self.ui_manager.start()
+            else:
+                self.console.print(
+                    Panel.fit(
+                        f"[bold blue]Setting up project: {project_name}[/bold blue]\n"
+                        f"[dim]Repository: {project_url}[/dim]\n"
+                        f"[dim]Goal: {goal}[/dim]",
+                        border_style="blue",
+                    )
+                )
+
             # Step 1: Setup Docker environment
             if self.config.ui_mode:
                 self.ui_manager.handle_event(UIEvent(
@@ -389,30 +393,54 @@ def setup_project(
                     ))
                 # Display final summary and stop UI manager
                 self.ui_manager.display_final_summary()
+                final_summary_shown = True
             else:
                 # Provide traditional summary
                 self._provide_setup_summary(success)
 
             cmd_logger.info(f"Project setup completed: success={success}")
-
-            # Cleanup command logger
-            session_logger = get_session_logger()
-            if session_logger:
-                session_logger.cleanup_command_logger(cmd_logger_id)
-
             return success
 
         except Exception as e:
             cmd_logger.error(f"Setup failed: {e}", exc_info=True)
             # Always show critical errors
             self.console.print(f"[bold red]❌ Setup failed: {e}[/bold red]")
+            return False
 
-            # Cleanup command logger
+        finally:
+            # Tear down the live UI on every exit path (early returns, exceptions,
+            # normal completion). If the happy-path branch above didn't get to
+            # `display_final_summary`, do it now so the user sees the failure
+            # state instead of a frozen spinner.
+            if self.config.ui_mode and self.ui_manager and not final_summary_shown:
+                # Any phase still in 'running' was aborted, not completed.
+                for phase, data in self.ui_manager.phases_data.items():
+                    if data.get("status") == "running":
+                        try:
+                            self.ui_manager.handle_event(UIEvent(
+                                event_type=EventType.PHASE_ERROR,
+                                message="Phase aborted",
+                                phase=phase,
+                                level="error",
+                            ))
+                        except Exception:
+                            pass
+                try:
+                    self.ui_manager.display_final_summary()
+                except Exception:
+                    # display_final_summary itself failed; at minimum stop Live.
+                    try:
+                        self.ui_manager.stop()
+                    except Exception:
+                        pass
+
+            # Always release the command-specific loguru handler.
             session_logger = get_session_logger()
             if session_logger:
-                session_logger.cleanup_command_logger(cmd_logger_id)
-
-            return False
+                try:
+                    session_logger.cleanup_command_logger(cmd_logger_id)
+                except Exception:
+                    pass
 
     def continue_project(self, project_name: str, additional_request: Optional[str] = None) -> bool:
         """Continue working on an existing project."""
@@ -486,20 +514,24 @@ def run_task(self, project_name: str, task_description: str) -> bool:
         cmd_logger, cmd_logger_id = create_command_logger("run", project_name)
         cmd_logger.info(f"Starting task execution: {task_description}")
 
-        # Initialize UI Manager if in UI mode
-        if self.config.ui_mode:
-            self.ui_manager = UIManager(project_name=project_name, console=self.console)
-            self.ui_manager.start()
-        else:
-            self.console.print(
-                Panel.fit(
-                    f"[bold cyan]Running task on: {project_name}[/bold cyan]\n"
-                    f"[dim]Task: {task_description}[/dim]",
-                    border_style="cyan",
-                )
-            )
+        # Track whether we already displayed the final UI summary so the
+        # cleanup `finally` below doesn't re-display or skip it incorrectly.
+        final_summary_shown = False
 
         try:
+            # Initialize UI Manager if in UI mode
+            if self.config.ui_mode:
+                self.ui_manager = UIManager(project_name=project_name, console=self.console)
+                self.ui_manager.start()
+            else:
+                self.console.print(
+                    Panel.fit(
+                        f"[bold cyan]Running task on: {project_name}[/bold cyan]\n"
+                        f"[dim]Task: {task_description}[/dim]",
+                        border_style="cyan",
+                    )
+                )
+
             # Step 1: Ensure Docker container is running
             if self.config.ui_mode:
                 self.ui_manager.handle_event(UIEvent(
@@ -626,33 +658,58 @@ def run_task(self, project_name: str, task_description: str) -> bool:
             # Step 7: Provide execution summary
             if self.config.ui_mode:
                 self.ui_manager.display_final_summary()
+                final_summary_shown = True
             else:
                 self._provide_task_summary(success, task_description)
 
             cmd_logger.info(f"Task execution completed: success={success}")
-
-            # Cleanup command logger
-            session_logger = get_session_logger()
-            if session_logger:
-                session_logger.cleanup_command_logger(cmd_logger_id)
-
             return success
 
         except Exception as e:
             cmd_logger.error(f"Task execution failed: {e}", exc_info=True)
             # Always show critical errors
             self.console.print(f"[bold red]❌ Task execution failed: {e}[/bold red]")
 
-            # Update last comment with error
-            error_comment = f"Task failed: {task_description} - Error: {str(e)[:100]}"
+            # Best-effort: record the failure on the container's last-comment marker.
+            try:
+                error_comment = f"Task failed: {task_description} - Error: {str(e)[:100]}"
+                self.orchestrator.update_last_comment(error_comment)
+            except Exception:
+                pass
+
+            return False
+
+        finally:
+            # Tear down the live UI on every exit path. Without this, early
+            # `return False` paths above would leave Rich's Live thread
+            # refreshing the terminal indefinitely and swallowing any error
+            # message printed afterwards.
+            if self.config.ui_mode and self.ui_manager and not final_summary_shown:
+                for phase, data in self.ui_manager.phases_data.items():
+                    if data.get("status") == "running":
+                        try:
+                            self.ui_manager.handle_event(UIEvent(
+                                event_type=EventType.PHASE_ERROR,
+                                message="Phase aborted",
+                                phase=phase,
+                                level="error",
+                            ))
+                        except Exception:
+                            pass
+                try:
+                    self.ui_manager.display_final_summary()
+                except Exception:
+                    try:
+                        self.ui_manager.stop()
+                    except Exception:
+                        pass
 
-            # Cleanup command logger
             session_logger = get_session_logger()
             if session_logger:
-                session_logger.cleanup_command_logger(cmd_logger_id)
-            self.orchestrator.update_last_comment(error_comment)
-
-            return False
+                try:
+                    session_logger.cleanup_command_logger(cmd_logger_id)
+                except Exception:
+                    pass
 
     def _setup_docker_environment(self, project_name: str) -> bool:
         """Setup the Docker environment for the project."""

main.py

@@ -314,9 +314,7 @@ def cli(ctx, log_level, log_file, verbose, ui):
             logger.info(f"Logs directory: {session_logger.session_log_dir}")
 
     # Display welcome message for main commands (skip in UI mode, will be shown by UIManager)
-    # Note: UI mode is only enabled at subcommand level, so we show it here in non-verbose mode
-    # It will be suppressed when actual UI starts
-    if ctx.invoked_subcommand not in ["list"] and not config.verbose:
+    if ctx.invoked_subcommand not in ["list"] and not config.verbose and not config.ui_mode:
         console.print(
             Panel.fit(
                 "[bold blue]SAG[/bold blue] - [dim]Setup Agent[/dim]\n"

ui/ui_manager.py

@@ -201,7 +201,7 @@ def _extract_thought_summary(self, thought: str) -> str:
             thought: Full thought content
 
         Returns:
-            Concise summary (30-80 chars) with ellipsis
+            Concise summary (up to 80 chars); ellipsis only when truncated
         """
         # Remove common prefixes
         thought = thought.strip()
@@ -214,12 +214,13 @@ def _extract_thought_summary(self, thought: str) -> str:
             # Limit length
             if len(summary) > 80:
                 summary = summary[:77] + "..."
-            elif len(summary) < 20:
+            elif len(summary) < 20 and len(sentences) > 1:
                 # If too short, include second sentence if available
-                if len(sentences) > 1:
-                    summary = f"{summary}. {sentences[1][:40]}..."
-            else:
-                summary = summary + "..."
+                second = sentences[1].strip()
+                if len(second) > 40:
+                    summary = f"{summary}. {second[:37]}..."
+                else:
+                    summary = f"{summary}. {second}"
 
             return summary
 
@@ -234,7 +235,7 @@ def _extract_observation_summary(self, observation: str) -> str:
             observation: Full observation content
 
         Returns:
-            Concise summary (50-100 chars) with ellipsis
+            Concise summary (up to 100 chars); ellipsis only when truncated
         """
         # Clean up observation
         observation = observation.strip()
@@ -246,28 +247,22 @@ def _extract_observation_summary(self, observation: str) -> str:
             for line in lines:
                 if "success" in line.lower():
                     summary = line.strip()
-                    if len(summary) > 100:
-                        return summary[:97] + "..."
-                    return summary + "..."
+                    return summary[:97] + "..." if len(summary) > 100 else summary
 
         # Look for error indicators
         if "error" in observation.lower() or "failed" in observation.lower():
             lines = observation.split("\n")
             for line in lines:
                 if "error" in line.lower() or "failed" in line.lower():
                     summary = line.strip()
-                    if len(summary) > 100:
-                        return summary[:97] + "..."
-                    return summary + "..."
+                    return summary[:97] + "..." if len(summary) > 100 else summary
 
         # Default: first meaningful line
         lines = observation.split("\n")
         for line in lines:
             line = line.strip()
             if len(line) > 10:  # Skip very short lines
-                if len(line) > 100:
-                    return line[:97] + "..."
-                return line + "..."
+                return line[:97] + "..." if len(line) > 100 else line
 
         # Fallback
         return observation[:97] + "..." if len(observation) > 100 else observation
@@ -483,16 +478,16 @@ def _handle_agent_event(self, event: UIEvent):
             self.agent_tool_params = tool_params
 
             # Detect phase transition based on tool usage
+            # NOTE: tool-name detection is a pure heuristic — it carries no signal
+            # about whether the previous phase actually succeeded. Updating
+            # `current_phase` is safe (it just drives the live indicator), but we
+            # must NOT mark the previous phase as "success" here; only explicit
+            # PHASE_COMPLETE / PHASE_ERROR events may transition phase status.
             detected_phase = self._detect_phase_from_action(tool_name, tool_params)
             if detected_phase and detected_phase != self.current_phase:
-                # Transition to new phase
-                # Complete previous phase if it was running
-                if self.current_phase and self.phases_data[self.current_phase]["status"] == "running":
-                    self.phases_data[self.current_phase]["status"] = "success"
-
-                # Start new phase
                 self.current_phase = detected_phase
-                self.phases_data[detected_phase]["status"] = "running"
+                if self.phases_data[detected_phase]["status"] == "pending":
+                    self.phases_data[detected_phase]["status"] = "running"
 
             # Format parameters for display
             params_str = self._format_tool_params(tool_name, tool_params)

website/index.html

@@ -153,10 +153,10 @@ <h2>Setup<br>Agent</h2>
     <span class="arch-title">How SAG Works.</span>
 
     <div class="arch-tabs">
-      <button class="arch-tab active" onclick="showTab('overview')">Overview</button>
-      <button class="arch-tab" onclick="showTab('dual')">Dual-Model</button>
-      <button class="arch-tab" onclick="showTab('docker')">Docker</button>
-      <button class="arch-tab" onclick="showTab('verify')">Validation</button>
+      <button class="arch-tab active" data-tab="overview" onclick="showTab(event, 'overview')">Overview</button>
+      <button class="arch-tab" data-tab="dual" onclick="showTab(event, 'dual')">Dual-Model</button>
+      <button class="arch-tab" data-tab="docker" onclick="showTab(event, 'docker')">Docker</button>
+      <button class="arch-tab" data-tab="verify" onclick="showTab(event, 'verify')">Validation</button>
     </div>
 
     <!-- Overview -->

website/js/main.js

@@ -3,22 +3,33 @@
  */
 
 // Architecture tab switching
-function showTab(name) {
+function showTab(event, name) {
   document.querySelectorAll('.arch-panel').forEach(function(p) {
     p.classList.remove('active');
   });
   document.querySelectorAll('.arch-tab').forEach(function(t) {
     t.classList.remove('active');
   });
   document.getElementById('p-' + name).classList.add('active');
-  event.target.classList.add('active');
+  if (event && event.currentTarget) {
+    event.currentTarget.classList.add('active');
+  } else {
+    var btn = document.querySelector('.arch-tab[data-tab="' + name + '"]');
+    if (btn) btn.classList.add('active');
+  }
 }
 
 // Copy-to-clipboard for command blocks and bibtex
 document.addEventListener('DOMContentLoaded', function() {
   document.querySelectorAll('.cp').forEach(function(btn) {
     btn.addEventListener('click', function() {
-      var container = btn.closest('.cmd') || btn.closest('.bibtex');
+      // In the install layout the button is a sibling of .cmd under
+      // .install-step, so closest('.cmd') would not find it — fall back to
+      // looking for a .cmd inside the surrounding .install-step wrapper.
+      var step = btn.closest('.install-step');
+      var container = btn.closest('.cmd')
+        || btn.closest('.bibtex')
+        || (step && step.querySelector('.cmd'));
       if (!container) return;
 
       var text;