strix-agent 0.4.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

strix/interface/tui.py

@@ -2,14 +2,13 @@ import argparse
 import asyncio
 import atexit
 import logging
-import random
 import signal
 import sys
 import threading
 from collections.abc import Callable
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as pkg_version
-from typing import TYPE_CHECKING, Any, ClassVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar
 
 
 if TYPE_CHECKING:
@@ -17,7 +16,6 @@ if TYPE_CHECKING:
 
 from rich.align import Align
 from rich.console import Group
-from rich.markup import escape as rich_escape
 from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
@@ -31,15 +29,11 @@ from textual.widgets import Button, Label, Static, TextArea, Tree
 from textual.widgets.tree import TreeNode
 
 from strix.agents.StrixAgent import StrixAgent
-from strix.interface.utils import build_live_stats_text
+from strix.interface.utils import build_tui_stats_text
 from strix.llm.config import LLMConfig
 from strix.telemetry.tracer import Tracer, set_global_tracer
 
 
-def escape_markup(text: str) -> str:
-    return cast("str", rich_escape(text))
-
-
 def get_package_version() -> str:
     try:
         return pkg_version("strix-agent")
@@ -55,7 +49,15 @@ class ChatTextArea(TextArea):  # type: ignore[misc]
     def set_app_reference(self, app: "StrixTUIApp") -> None:
         self._app_reference = app
 
+    def on_mount(self) -> None:
+        self._update_height()
+
     def _on_key(self, event: events.Key) -> None:
+        if event.key == "shift+enter":
+            self.insert("\n")
+            event.prevent_default()
+            return
+
         if event.key == "enter" and self._app_reference:
             text_content = str(self.text)  # type: ignore[has-type]
             message = text_content.strip()
@@ -69,6 +71,20 @@ class ChatTextArea(TextArea):  # type: ignore[misc]
 
         super()._on_key(event)
 
+    @on(TextArea.Changed)  # type: ignore[misc]
+    def _update_height(self, _event: TextArea.Changed | None = None) -> None:
+        if not self.parent:
+            return
+
+        line_count = self.document.line_count
+        target_lines = min(max(1, line_count), 8)
+
+        new_height = target_lines + 2
+
+        if self.parent.styles.height != new_height:
+            self.parent.styles.height = new_height
+            self.scroll_cursor_visible()
+
 
 class SplashScreen(Static):  # type: ignore[misc]
     PRIMARY_GREEN = "#22c55e"
@@ -99,7 +115,7 @@ class SplashScreen(Static):  # type: ignore[misc]
         yield panel_static
 
     def on_mount(self) -> None:
-        self._animation_timer = self.set_interval(0.45, self._animate_start_line)
+        self._animation_timer = self.set_interval(0.05, self._animate_start_line)
 
     def on_unmount(self) -> None:
         if self._animation_timer is not None:
@@ -124,10 +140,15 @@ class SplashScreen(Static):  # type: ignore[misc]
             Align.center(self._build_tagline_text()),
             Align.center(Text(" ")),
             Align.center(start_line.copy()),
+            Align.center(Text(" ")),
+            Align.center(self._build_url_text()),
         )
 
         return Panel.fit(content, border_style=self.PRIMARY_GREEN, padding=(1, 6))
 
+    def _build_url_text(self) -> Text:
+        return Text("strix.ai", style=Style(color=self.PRIMARY_GREEN, bold=True))
+
     def _build_welcome_text(self) -> Text:
         text = Text("Welcome to ", style=Style(color="white", bold=True))
         text.append("Strix", style=Style(color=self.PRIMARY_GREEN, bold=True))
@@ -141,13 +162,25 @@ class SplashScreen(Static):  # type: ignore[misc]
         return Text("Open-source AI hackers for your apps", style=Style(color="white", dim=True))
 
     def _build_start_line_text(self, phase: int) -> Text:
-        emphasize = phase % 2 == 1
-        base_style = Style(color="white", dim=not emphasize, bold=emphasize)
-        strix_style = Style(color=self.PRIMARY_GREEN, bold=bool(emphasize))
+        full_text = "Starting Strix Agent"
+        text_len = len(full_text)
 
-        text = Text("Starting ", style=base_style)
-        text.append("Strix", style=strix_style)
-        text.append(" Cybersecurity Agent", style=base_style)
+        shine_pos = phase % (text_len + 8)
+
+        text = Text()
+        for i, char in enumerate(full_text):
+            dist = abs(i - shine_pos)
+
+            if dist <= 1:
+                style = Style(color="bright_white", bold=True)
+            elif dist <= 3:
+                style = Style(color="white", bold=True)
+            elif dist <= 5:
+                style = Style(color="#a3a3a3")
+            else:
+                style = Style(color="#525252")
+
+            text.append(char, style=style)
 
         return text
 
@@ -217,10 +250,377 @@ class StopAgentScreen(ModalScreen):  # type: ignore[misc]
             self.app.pop_screen()
 
 
+class VulnerabilityDetailScreen(ModalScreen):  # type: ignore[misc]
+    """Modal screen to display vulnerability details."""
+
+    SEVERITY_COLORS: ClassVar[dict[str, str]] = {
+        "critical": "#dc2626",  # Red
+        "high": "#ea580c",  # Orange
+        "medium": "#d97706",  # Amber
+        "low": "#22c55e",  # Green
+        "info": "#3b82f6",  # Blue
+    }
+
+    FIELD_STYLE: ClassVar[str] = "bold #4ade80"
+
+    def __init__(self, vulnerability: dict[str, Any]) -> None:
+        super().__init__()
+        self.vulnerability = vulnerability
+
+    def compose(self) -> ComposeResult:
+        content = self._render_vulnerability()
+        yield Grid(
+            VerticalScroll(Static(content, id="vuln_detail_content"), id="vuln_detail_scroll"),
+            Horizontal(
+                Button("Copy", variant="default", id="copy_vuln_detail"),
+                Button("Done", variant="default", id="close_vuln_detail"),
+                id="vuln_detail_buttons",
+            ),
+            id="vuln_detail_dialog",
+        )
+
+    def on_mount(self) -> None:
+        close_button = self.query_one("#close_vuln_detail", Button)
+        close_button.focus()
+
+    def _get_cvss_color(self, cvss_score: float) -> str:
+        if cvss_score >= 9.0:
+            return "#dc2626"
+        if cvss_score >= 7.0:
+            return "#ea580c"
+        if cvss_score >= 4.0:
+            return "#d97706"
+        if cvss_score >= 0.1:
+            return "#65a30d"
+        return "#6b7280"
+
+    def _highlight_python(self, code: str) -> Text:
+        try:
+            from pygments.lexers import PythonLexer
+            from pygments.styles import get_style_by_name
+
+            lexer = PythonLexer()
+            style = get_style_by_name("native")
+            colors = {
+                token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]
+            }
+
+            text = Text()
+            for token_type, token_value in lexer.get_tokens(code):
+                if not token_value:
+                    continue
+                color = None
+                tt = token_type
+                while tt:
+                    if tt in colors:
+                        color = colors[tt]
+                        break
+                    tt = tt.parent
+                text.append(token_value, style=color)
+        except (ImportError, KeyError, AttributeError):
+            return Text(code)
+        else:
+            return text
+
+    def _render_vulnerability(self) -> Text:  # noqa: PLR0912, PLR0915
+        vuln = self.vulnerability
+        text = Text()
+
+        text.append("🐞 ")
+        text.append("Vulnerability Report", style="bold #ea580c")
+
+        agent_name = vuln.get("agent_name", "")
+        if agent_name:
+            text.append("\n\n")
+            text.append("Agent: ", style=self.FIELD_STYLE)
+            text.append(agent_name)
+
+        title = vuln.get("title", "")
+        if title:
+            text.append("\n\n")
+            text.append("Title: ", style=self.FIELD_STYLE)
+            text.append(title)
+
+        severity = vuln.get("severity", "")
+        if severity:
+            text.append("\n\n")
+            text.append("Severity: ", style=self.FIELD_STYLE)
+            severity_color = self.SEVERITY_COLORS.get(severity.lower(), "#6b7280")
+            text.append(severity.upper(), style=f"bold {severity_color}")
+
+        cvss_score = vuln.get("cvss")
+        if cvss_score is not None:
+            text.append("\n\n")
+            text.append("CVSS Score: ", style=self.FIELD_STYLE)
+            cvss_color = self._get_cvss_color(float(cvss_score))
+            text.append(str(cvss_score), style=f"bold {cvss_color}")
+
+        target = vuln.get("target", "")
+        if target:
+            text.append("\n\n")
+            text.append("Target: ", style=self.FIELD_STYLE)
+            text.append(target)
+
+        endpoint = vuln.get("endpoint", "")
+        if endpoint:
+            text.append("\n\n")
+            text.append("Endpoint: ", style=self.FIELD_STYLE)
+            text.append(endpoint)
+
+        method = vuln.get("method", "")
+        if method:
+            text.append("\n\n")
+            text.append("Method: ", style=self.FIELD_STYLE)
+            text.append(method)
+
+        cve = vuln.get("cve", "")
+        if cve:
+            text.append("\n\n")
+            text.append("CVE: ", style=self.FIELD_STYLE)
+            text.append(cve)
+
+        # CVSS breakdown
+        cvss_breakdown = vuln.get("cvss_breakdown", {})
+        if cvss_breakdown:
+            cvss_parts = []
+            if cvss_breakdown.get("attack_vector"):
+                cvss_parts.append(f"AV:{cvss_breakdown['attack_vector']}")
+            if cvss_breakdown.get("attack_complexity"):
+                cvss_parts.append(f"AC:{cvss_breakdown['attack_complexity']}")
+            if cvss_breakdown.get("privileges_required"):
+                cvss_parts.append(f"PR:{cvss_breakdown['privileges_required']}")
+            if cvss_breakdown.get("user_interaction"):
+                cvss_parts.append(f"UI:{cvss_breakdown['user_interaction']}")
+            if cvss_breakdown.get("scope"):
+                cvss_parts.append(f"S:{cvss_breakdown['scope']}")
+            if cvss_breakdown.get("confidentiality"):
+                cvss_parts.append(f"C:{cvss_breakdown['confidentiality']}")
+            if cvss_breakdown.get("integrity"):
+                cvss_parts.append(f"I:{cvss_breakdown['integrity']}")
+            if cvss_breakdown.get("availability"):
+                cvss_parts.append(f"A:{cvss_breakdown['availability']}")
+            if cvss_parts:
+                text.append("\n\n")
+                text.append("CVSS Vector: ", style=self.FIELD_STYLE)
+                text.append("/".join(cvss_parts), style="dim")
+
+        description = vuln.get("description", "")
+        if description:
+            text.append("\n\n")
+            text.append("Description", style=self.FIELD_STYLE)
+            text.append("\n")
+            text.append(description)
+
+        impact = vuln.get("impact", "")
+        if impact:
+            text.append("\n\n")
+            text.append("Impact", style=self.FIELD_STYLE)
+            text.append("\n")
+            text.append(impact)
+
+        technical_analysis = vuln.get("technical_analysis", "")
+        if technical_analysis:
+            text.append("\n\n")
+            text.append("Technical Analysis", style=self.FIELD_STYLE)
+            text.append("\n")
+            text.append(technical_analysis)
+
+        poc_description = vuln.get("poc_description", "")
+        if poc_description:
+            text.append("\n\n")
+            text.append("PoC Description", style=self.FIELD_STYLE)
+            text.append("\n")
+            text.append(poc_description)
+
+        poc_script_code = vuln.get("poc_script_code", "")
+        if poc_script_code:
+            text.append("\n\n")
+            text.append("PoC Code", style=self.FIELD_STYLE)
+            text.append("\n")
+            text.append_text(self._highlight_python(poc_script_code))
+
+        remediation_steps = vuln.get("remediation_steps", "")
+        if remediation_steps:
+            text.append("\n\n")
+            text.append("Remediation", style=self.FIELD_STYLE)
+            text.append("\n")
+            text.append(remediation_steps)
+
+        return text
+
+    def _get_markdown_report(self) -> str:  # noqa: PLR0912, PLR0915
+        """Get Markdown version of vulnerability report for clipboard."""
+        vuln = self.vulnerability
+        lines: list[str] = []
+
+        # Title
+        title = vuln.get("title", "Untitled Vulnerability")
+        lines.append(f"# {title}")
+        lines.append("")
+
+        # Metadata
+        if vuln.get("id"):
+            lines.append(f"**ID:** {vuln['id']}")
+        if vuln.get("severity"):
+            lines.append(f"**Severity:** {vuln['severity'].upper()}")
+        if vuln.get("timestamp"):
+            lines.append(f"**Found:** {vuln['timestamp']}")
+        if vuln.get("agent_name"):
+            lines.append(f"**Agent:** {vuln['agent_name']}")
+        if vuln.get("target"):
+            lines.append(f"**Target:** {vuln['target']}")
+        if vuln.get("endpoint"):
+            lines.append(f"**Endpoint:** {vuln['endpoint']}")
+        if vuln.get("method"):
+            lines.append(f"**Method:** {vuln['method']}")
+        if vuln.get("cve"):
+            lines.append(f"**CVE:** {vuln['cve']}")
+        if vuln.get("cvss") is not None:
+            lines.append(f"**CVSS:** {vuln['cvss']}")
+
+        # CVSS Vector
+        cvss_breakdown = vuln.get("cvss_breakdown", {})
+        if cvss_breakdown:
+            abbrevs = {
+                "attack_vector": "AV",
+                "attack_complexity": "AC",
+                "privileges_required": "PR",
+                "user_interaction": "UI",
+                "scope": "S",
+                "confidentiality": "C",
+                "integrity": "I",
+                "availability": "A",
+            }
+            parts = [
+                f"{abbrevs.get(k, k)}:{v}" for k, v in cvss_breakdown.items() if v and k in abbrevs
+            ]
+            if parts:
+                lines.append(f"**CVSS Vector:** {'/'.join(parts)}")
+
+        # Description
+        lines.append("")
+        lines.append("## Description")
+        lines.append("")
+        lines.append(vuln.get("description") or "No description provided.")
+
+        # Impact
+        if vuln.get("impact"):
+            lines.extend(["", "## Impact", "", vuln["impact"]])
+
+        # Technical Analysis
+        if vuln.get("technical_analysis"):
+            lines.extend(["", "## Technical Analysis", "", vuln["technical_analysis"]])
+
+        # Proof of Concept
+        if vuln.get("poc_description") or vuln.get("poc_script_code"):
+            lines.extend(["", "## Proof of Concept", ""])
+            if vuln.get("poc_description"):
+                lines.append(vuln["poc_description"])
+                lines.append("")
+            if vuln.get("poc_script_code"):
+                lines.append("```python")
+                lines.append(vuln["poc_script_code"])
+                lines.append("```")
+
+        # Code Analysis
+        if vuln.get("code_file") or vuln.get("code_diff"):
+            lines.extend(["", "## Code Analysis", ""])
+            if vuln.get("code_file"):
+                lines.append(f"**File:** {vuln['code_file']}")
+                lines.append("")
+            if vuln.get("code_diff"):
+                lines.append("**Changes:**")
+                lines.append("```diff")
+                lines.append(vuln["code_diff"])
+                lines.append("```")
+
+        # Remediation
+        if vuln.get("remediation_steps"):
+            lines.extend(["", "## Remediation", "", vuln["remediation_steps"]])
+
+        lines.append("")
+        return "\n".join(lines)
+
+    def on_key(self, event: events.Key) -> None:
+        if event.key == "escape":
+            self.app.pop_screen()
+            event.prevent_default()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "copy_vuln_detail":
+            markdown_text = self._get_markdown_report()
+            self.app.copy_to_clipboard(markdown_text)
+
+            copy_button = self.query_one("#copy_vuln_detail", Button)
+            copy_button.label = "Copied!"
+            self.set_timer(1.5, lambda: setattr(copy_button, "label", "Copy"))
+        elif event.button.id == "close_vuln_detail":
+            self.app.pop_screen()
+
+
+class VulnerabilityItem(Static):  # type: ignore[misc]
+    """A clickable vulnerability item."""
+
+    def __init__(self, label: Text, vuln_data: dict[str, Any], **kwargs: Any) -> None:
+        super().__init__(label, **kwargs)
+        self.vuln_data = vuln_data
+
+    def on_click(self, _event: events.Click) -> None:
+        """Handle click to open vulnerability detail."""
+        self.app.push_screen(VulnerabilityDetailScreen(self.vuln_data))
+
+
+class VulnerabilitiesPanel(VerticalScroll):  # type: ignore[misc]
+    """A scrollable panel showing found vulnerabilities with severity-colored dots."""
+
+    SEVERITY_COLORS: ClassVar[dict[str, str]] = {
+        "critical": "#dc2626",  # Red
+        "high": "#ea580c",  # Orange
+        "medium": "#d97706",  # Amber
+        "low": "#22c55e",  # Green
+        "info": "#3b82f6",  # Blue
+    }
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._vulnerabilities: list[dict[str, Any]] = []
+
+    def compose(self) -> ComposeResult:
+        return []
+
+    def update_vulnerabilities(self, vulnerabilities: list[dict[str, Any]]) -> None:
+        """Update the list of vulnerabilities and re-render."""
+        if self._vulnerabilities == vulnerabilities:
+            return
+        self._vulnerabilities = list(vulnerabilities)
+        self._render_panel()
+
+    def _render_panel(self) -> None:
+        """Render the vulnerabilities panel content."""
+        for child in list(self.children):
+            if isinstance(child, VulnerabilityItem):
+                child.remove()
+
+        if not self._vulnerabilities:
+            return
+
+        for vuln in self._vulnerabilities:
+            severity = vuln.get("severity", "info").lower()
+            title = vuln.get("title", "Unknown Vulnerability")
+            color = self.SEVERITY_COLORS.get(severity, "#3b82f6")
+
+            label = Text()
+            label.append("● ", style=Style(color=color))
+            label.append(title, style=Style(color="#d4d4d4"))
+
+            item = VulnerabilityItem(label, vuln, classes="vuln-item")
+            self.mount(item)
+
+
 class QuitScreen(ModalScreen):  # type: ignore[misc]
     def compose(self) -> ComposeResult:
         yield Grid(
-            Label("🦉 Quit Strix? ", id="quit_title"),
+            Label("Quit Strix?", id="quit_title"),
             Grid(
                 Button("Yes", variant="error", id="quit"),
                 Button("No", variant="default", id="cancel"),
@@ -264,6 +664,8 @@ class QuitScreen(ModalScreen):  # type: ignore[misc]
 class StrixTUIApp(App):  # type: ignore[misc]
     CSS_PATH = "assets/tui_styles.tcss"
 
+    SIDEBAR_MIN_WIDTH = 100
+
     selected_agent_id: reactive[str | None] = reactive(default=None)
     show_splash: reactive[bool] = reactive(default=True)
 
@@ -293,19 +695,18 @@ class StrixTUIApp(App):  # type: ignore[misc]
         self._scan_stop_event = threading.Event()
         self._scan_completed = threading.Event()
 
-        self._action_verbs = [
-            "Generating",
-            "Scanning",
-            "Analyzing",
-            "Probing",
-            "Hacking",
-            "Testing",
-            "Exploiting",
-            "Investigating",
+        self._spinner_frame_index: int = 0  # Current animation frame index
+        self._sweep_num_squares: int = 6  # Number of squares in sweep animation
+        self._sweep_colors: list[str] = [
+            "#000000",  # Dimmest (shows dot)
+            "#031a09",
+            "#052e16",
+            "#0d4a2a",
+            "#15803d",
+            "#22c55e",
+            "#4ade80",
+            "#86efac",  # Brightest
         ]
-        self._agent_verbs: dict[str, str] = {}  # agent_id -> current_verb
-        self._agent_verb_timers: dict[str, Any] = {}  # agent_id -> timer
-        self._agent_dot_states: dict[str, int] = {}  # agent_id -> dot_count (0-3)
         self._dot_animation_timer: Any | None = None
 
         self._setup_cleanup_handlers()
@@ -319,7 +720,8 @@ class StrixTUIApp(App):  # type: ignore[misc]
         }
 
     def _build_agent_config(self, args: argparse.Namespace) -> dict[str, Any]:
-        llm_config = LLMConfig()
+        scan_mode = getattr(args, "scan_mode", "deep")
+        llm_config = LLMConfig(scan_mode=scan_mode)
 
         config = {
             "llm_config": llm_config,
@@ -396,7 +798,9 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
             stats_display = Static("", id="stats_display")
 
-            sidebar = Vertical(agents_tree, stats_display, id="sidebar")
+            vulnerabilities_panel = VulnerabilitiesPanel(id="vulnerabilities_panel")
+
+            sidebar = Vertical(agents_tree, vulnerabilities_panel, stats_display, id="sidebar")
 
             content_container.mount(chat_area_container)
             content_container.mount(sidebar)
@@ -449,7 +853,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
         self._start_scan_thread()
 
-        self.set_interval(0.5, self._update_ui_from_tracer)
+        self.set_interval(0.25, self._update_ui_from_tracer)
 
     def _update_ui_from_tracer(self) -> None:
         if self.show_splash:
@@ -471,7 +875,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
             return
 
         agent_updates = False
-        for agent_id, agent_data in self.tracer.agents.items():
+        for agent_id, agent_data in list(self.tracer.agents.items()):
             if agent_id not in self._displayed_agents:
                 self._add_agent_node(agent_data)
                 self._displayed_agents.add(agent_id)
@@ -480,7 +884,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
                 agent_updates = True
 
         if agent_updates:
-            self._expand_all_agent_nodes()
+            self._expand_new_agent_nodes()
 
         self._update_chat_view()
 
@@ -488,6 +892,8 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
         self._update_stats_display()
 
+        self._update_vulnerabilities_panel()
+
     def _update_agent_node(self, agent_id: str, agent_data: dict[str, Any]) -> bool:
         if agent_id not in self.agent_nodes:
             return False
@@ -508,14 +914,9 @@ class StrixTUIApp(App):  # type: ignore[misc]
             }
 
             status_icon = status_indicators.get(status, "🔵")
-            agent_name = f"{status_icon} {escape_markup(agent_name_raw)}"
-
-            if status == "running":
-                self._start_agent_verb_timer(agent_id)
-            elif status == "waiting":
-                self._stop_agent_verb_timer(agent_id)
-            else:
-                self._stop_agent_verb_timer(agent_id)
+            vuln_count = self._agent_vulnerability_count(agent_id)
+            vuln_indicator = f" ({vuln_count})" if vuln_count > 0 else ""
+            agent_name = f"{status_icon} {agent_name_raw}{vuln_indicator}"
 
             if agent_node.label != agent_name:
                 agent_node.set_label(agent_name)
@@ -528,11 +929,32 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
         return False
 
-    def _update_chat_view(self) -> None:
-        if len(self.screen_stack) > 1 or self.show_splash:
-            return
+    def _get_chat_content(
+        self,
+    ) -> tuple[Any, str | None]:
+        if not self.selected_agent_id:
+            return self._get_chat_placeholder_content(
+                "Select an agent from the tree to see its activity.", "placeholder-no-agent"
+            )
 
-        if not self.is_mounted:
+        events = self._gather_agent_events(self.selected_agent_id)
+        streaming = self.tracer.get_streaming_content(self.selected_agent_id)
+
+        if not events and not streaming:
+            return self._get_chat_placeholder_content(
+                "Starting agent...", "placeholder-no-activity"
+            )
+
+        current_event_ids = [e["id"] for e in events]
+
+        if not streaming and current_event_ids == self._displayed_events:
+            return None, None
+
+        self._displayed_events = current_event_ids
+        return self._get_rendered_events_content(events), "chat-content"
+
+    def _update_chat_view(self) -> None:
+        if len(self.screen_stack) > 1 or self.show_splash or not self.is_mounted:
             return
 
         try:
@@ -548,27 +970,12 @@ class StrixTUIApp(App):  # type: ignore[misc]
         except (AttributeError, ValueError):
             is_at_bottom = True
 
-        if not self.selected_agent_id:
-            content, css_class = self._get_chat_placeholder_content(
-                "Select an agent from the tree to see its activity.", "placeholder-no-agent"
-            )
-        else:
-            events = self._gather_agent_events(self.selected_agent_id)
-            if not events:
-                content, css_class = self._get_chat_placeholder_content(
-                    "Starting agent...", "placeholder-no-activity"
-                )
-            else:
-                current_event_ids = [e["id"] for e in events]
-                if current_event_ids == self._displayed_events:
-                    return
-                content = self._get_rendered_events_content(events)
-                css_class = "chat-content"
-                self._displayed_events = current_event_ids
+        content, css_class = self._get_chat_content()
+        if content is None:
+            return
 
         chat_display = self.query_one("#chat_display", Static)
-        self._update_static_content_safe(chat_display, content)
-
+        self._safe_widget_operation(chat_display.update, content)
         chat_display.set_classes(css_class)
 
         if is_at_bottom:
@@ -576,26 +983,181 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
     def _get_chat_placeholder_content(
         self, message: str, placeholder_class: str
-    ) -> tuple[str, str]:
+    ) -> tuple[Text, str]:
         self._displayed_events = [placeholder_class]
-        return message, f"chat-placeholder {placeholder_class}"
+        text = Text()
+        text.append(message)
+        return text, f"chat-placeholder {placeholder_class}"
+
+    def _get_rendered_events_content(self, events: list[dict[str, Any]]) -> Any:
+        renderables: list[Any] = []
 
-    def _get_rendered_events_content(self, events: list[dict[str, Any]]) -> str:
         if not events:
-            return ""
+            return Text()
 
-        content_lines = []
         for event in events:
+            content: Any = None
+
             if event["type"] == "chat":
-                chat_content = self._render_chat_content(event["data"])
-                if chat_content:
-                    content_lines.append(chat_content)
+                content = self._render_chat_content(event["data"])
             elif event["type"] == "tool":
-                tool_content = self._render_tool_content_simple(event["data"])
-                if tool_content:
-                    content_lines.append(tool_content)
+                content = self._render_tool_content_simple(event["data"])
+
+            if content:
+                if renderables:
+                    renderables.append(Text(""))
+                renderables.append(content)
+
+        if self.selected_agent_id:
+            streaming = self.tracer.get_streaming_content(self.selected_agent_id)
+            if streaming:
+                streaming_text = self._render_streaming_content(streaming)
+                if streaming_text:
+                    if renderables:
+                        renderables.append(Text(""))
+                    renderables.append(streaming_text)
+
+        if not renderables:
+            return Text()
+
+        if len(renderables) == 1:
+            return renderables[0]
+
+        return Group(*renderables)
 
-        return "\n\n".join(content_lines)
+    def _render_streaming_content(self, content: str) -> Any:
+        from strix.interface.streaming_parser import parse_streaming_content
+
+        renderables: list[Any] = []
+        segments = parse_streaming_content(content)
+
+        for segment in segments:
+            if segment.type == "text":
+                from strix.interface.tool_components.agent_message_renderer import (
+                    AgentMessageRenderer,
+                )
+
+                text_content = AgentMessageRenderer.render_simple(segment.content)
+                if renderables:
+                    renderables.append(Text(""))
+                renderables.append(text_content)
+
+            elif segment.type == "tool":
+                tool_renderable = self._render_streaming_tool(
+                    segment.tool_name or "unknown",
+                    segment.args or {},
+                    segment.is_complete,
+                )
+                if renderables:
+                    renderables.append(Text(""))
+                renderables.append(tool_renderable)
+
+        if not renderables:
+            return Text()
+
+        if len(renderables) == 1:
+            return renderables[0]
+
+        return Group(*renderables)
+
+    def _render_streaming_tool(
+        self, tool_name: str, args: dict[str, str], is_complete: bool
+    ) -> Any:
+        from strix.interface.tool_components.registry import get_tool_renderer
+
+        tool_data = {
+            "tool_name": tool_name,
+            "args": args,
+            "status": "completed" if is_complete else "running",
+            "result": None,
+        }
+
+        renderer = get_tool_renderer(tool_name)
+        if renderer:
+            widget = renderer.render(tool_data)
+            return widget.renderable
+
+        return self._render_default_streaming_tool(tool_name, args, is_complete)
+
+    def _render_default_streaming_tool(
+        self, tool_name: str, args: dict[str, str], is_complete: bool
+    ) -> Text:
+        text = Text()
+
+        if is_complete:
+            text.append("✓ ", style="green")
+        else:
+            text.append("● ", style="yellow")
+
+        text.append("Using tool ", style="dim")
+        text.append(tool_name, style="bold blue")
+
+        if args:
+            for key, value in list(args.items())[:3]:
+                text.append("\n  ")
+                text.append(key, style="dim")
+                text.append(": ")
+                display_value = value if len(value) <= 100 else value[:97] + "..."
+                text.append(display_value, style="italic" if not is_complete else None)
+
+        return text
+
+    def _get_status_display_content(
+        self, agent_id: str, agent_data: dict[str, Any]
+    ) -> tuple[Text | None, Text, bool]:
+        status = agent_data.get("status", "running")
+
+        def keymap_styled(keys: list[tuple[str, str]]) -> Text:
+            t = Text()
+            for i, (key, action) in enumerate(keys):
+                if i > 0:
+                    t.append(" · ", style="dim")
+                t.append(key, style="white")
+                t.append(" ", style="dim")
+                t.append(action, style="dim")
+            return t
+
+        simple_statuses: dict[str, tuple[str, str]] = {
+            "stopping": ("Agent stopping...", ""),
+            "stopped": ("Agent stopped", ""),
+            "completed": ("Agent completed", ""),
+        }
+
+        if status in simple_statuses:
+            msg, _ = simple_statuses[status]
+            text = Text()
+            text.append(msg)
+            return (text, Text(), False)
+
+        if status == "llm_failed":
+            error_msg = agent_data.get("error_message", "")
+            text = Text()
+            if error_msg:
+                text.append(error_msg, style="red")
+            else:
+                text.append("LLM request failed", style="red")
+            self._stop_dot_animation()
+            keymap = Text()
+            keymap.append("Send message to retry", style="dim")
+            return (text, keymap, False)
+
+        if status == "waiting":
+            keymap = Text()
+            keymap.append("Send message to resume", style="dim")
+            return (Text(" "), keymap, False)
+
+        if status == "running":
+            if self._agent_has_real_activity(agent_id):
+                animated_text = Text()
+                animated_text.append_text(self._get_sweep_animation(self._sweep_colors))
+                animated_text.append("esc", style="white")
+                animated_text.append(" ", style="dim")
+                animated_text.append("stop", style="dim")
+                return (animated_text, keymap_styled([("ctrl-q", "quit")]), True)
+            animated_text = self._get_animated_verb_text(agent_id, "Initializing")
+            return (animated_text, keymap_styled([("ctrl-q", "quit")]), True)
+
+        return (None, Text(), False)
 
     def _update_agent_status_display(self) -> None:
         try:
@@ -615,52 +1177,20 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
         try:
             agent_data = self.tracer.agents[self.selected_agent_id]
-            status = agent_data.get("status", "running")
+            content, keymap, should_animate = self._get_status_display_content(
+                self.selected_agent_id, agent_data
+            )
 
-            if status == "stopping":
-                self._safe_widget_operation(status_text.update, "Agent stopping...")
-                self._safe_widget_operation(keymap_indicator.update, "")
-                self._safe_widget_operation(status_display.remove_class, "hidden")
-            elif status == "stopped":
-                self._safe_widget_operation(status_text.update, "Agent stopped")
-                self._safe_widget_operation(keymap_indicator.update, "")
-                self._safe_widget_operation(status_display.remove_class, "hidden")
-            elif status == "completed":
-                self._safe_widget_operation(status_text.update, "Agent completed")
-                self._safe_widget_operation(keymap_indicator.update, "")
-                self._safe_widget_operation(status_display.remove_class, "hidden")
-            elif status == "llm_failed":
-                error_msg = agent_data.get("error_message", "")
-                display_msg = (
-                    f"[red]{escape_markup(error_msg)}[/red]"
-                    if error_msg
-                    else "[red]LLM request failed[/red]"
-                )
-                self._safe_widget_operation(status_text.update, display_msg)
-                self._safe_widget_operation(
-                    keymap_indicator.update, "[dim]Send message to retry[/dim]"
-                )
-                self._safe_widget_operation(status_display.remove_class, "hidden")
-                self._stop_dot_animation()
-            elif status == "waiting":
-                animated_text = self._get_animated_waiting_text(self.selected_agent_id)
-                self._safe_widget_operation(status_text.update, animated_text)
-                self._safe_widget_operation(
-                    keymap_indicator.update, "[dim]Send message to resume[/dim]"
-                )
-                self._safe_widget_operation(status_display.remove_class, "hidden")
-                self._start_dot_animation()
-            elif status == "running":
-                current_verb = self._get_agent_verb(self.selected_agent_id)
-                animated_text = self._get_animated_verb_text(self.selected_agent_id, current_verb)
-                self._safe_widget_operation(status_text.update, animated_text)
-                self._safe_widget_operation(
-                    keymap_indicator.update, "[dim]ESC to stop | CTRL-C to quit and save[/dim]"
-                )
-                self._safe_widget_operation(status_display.remove_class, "hidden")
-                self._start_dot_animation()
-            else:
+            if not content:
                 self._safe_widget_operation(status_display.add_class, "hidden")
+                return
+
+            self._safe_widget_operation(status_text.update, content)
+            self._safe_widget_operation(keymap_indicator.update, keymap)
+            self._safe_widget_operation(status_display.remove_class, "hidden")
+
+            if should_animate:
+                self._start_dot_animation()
 
         except (KeyError, Exception):
             self._safe_widget_operation(status_display.add_class, "hidden")
@@ -676,7 +1206,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
         stats_content = Text()
 
-        stats_text = build_live_stats_text(self.tracer)
+        stats_text = build_tui_stats_text(self.tracer, self.agent_config)
         if stats_text:
             stats_content.append(stats_text)
 
@@ -684,62 +1214,95 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
         stats_panel = Panel(
             stats_content,
-            title="📊 Live Stats",
-            title_align="left",
-            border_style="#22c55e",
+            border_style="#333333",
             padding=(0, 1),
         )
 
         self._safe_widget_operation(stats_display.update, stats_panel)
 
-    def _get_agent_verb(self, agent_id: str) -> str:
-        if agent_id not in self._agent_verbs:
-            self._agent_verbs[agent_id] = random.choice(self._action_verbs)  # nosec B311 # noqa: S311
-        return self._agent_verbs[agent_id]
-
-    def _start_agent_verb_timer(self, agent_id: str) -> None:
-        if agent_id not in self._agent_verb_timers:
-            self._agent_verb_timers[agent_id] = self.set_interval(
-                30.0, lambda: self._change_agent_action_verb(agent_id)
-            )
-
-    def _stop_agent_verb_timer(self, agent_id: str) -> None:
-        if agent_id in self._agent_verb_timers:
-            self._agent_verb_timers[agent_id].stop()
-            del self._agent_verb_timers[agent_id]
-
-    def _change_agent_action_verb(self, agent_id: str) -> None:
-        if agent_id not in self._agent_verbs:
-            self._agent_verbs[agent_id] = random.choice(self._action_verbs)  # nosec B311 # noqa: S311
+    def _update_vulnerabilities_panel(self) -> None:
+        """Update the vulnerabilities panel with current vulnerability data."""
+        try:
+            vuln_panel = self.query_one("#vulnerabilities_panel", VulnerabilitiesPanel)
+        except (ValueError, Exception):
             return
 
-        current_verb = self._agent_verbs[agent_id]
-        available_verbs = [verb for verb in self._action_verbs if verb != current_verb]
-        self._agent_verbs[agent_id] = random.choice(available_verbs)  # nosec B311 # noqa: S311
-
-        if self.selected_agent_id == agent_id:
-            self._update_agent_status_display()
+        if not self._is_widget_safe(vuln_panel):
+            return
 
-    def _get_animated_verb_text(self, agent_id: str, verb: str) -> str:
-        if agent_id not in self._agent_dot_states:
-            self._agent_dot_states[agent_id] = 0
+        vulnerabilities = self.tracer.vulnerability_reports
 
-        dot_count = self._agent_dot_states[agent_id]
-        dots = "." * dot_count
-        return f"{verb}{dots}"
+        if not vulnerabilities:
+            self._safe_widget_operation(vuln_panel.add_class, "hidden")
+            return
 
-    def _get_animated_waiting_text(self, agent_id: str) -> str:
-        if agent_id not in self._agent_dot_states:
-            self._agent_dot_states[agent_id] = 0
+        enriched_vulns = []
+        for vuln in vulnerabilities:
+            enriched = dict(vuln)
+            report_id = vuln.get("id", "")
+            agent_name = self._get_agent_name_for_vulnerability(report_id)
+            if agent_name:
+                enriched["agent_name"] = agent_name
+            enriched_vulns.append(enriched)
+
+        self._safe_widget_operation(vuln_panel.remove_class, "hidden")
+        vuln_panel.update_vulnerabilities(enriched_vulns)
+
+    def _get_agent_name_for_vulnerability(self, report_id: str) -> str | None:
+        """Find the agent name that created a vulnerability report."""
+        for _exec_id, tool_data in list(self.tracer.tool_executions.items()):
+            if tool_data.get("tool_name") == "create_vulnerability_report":
+                result = tool_data.get("result", {})
+                if isinstance(result, dict) and result.get("report_id") == report_id:
+                    agent_id = tool_data.get("agent_id")
+                    if agent_id and agent_id in self.tracer.agents:
+                        name: str = self.tracer.agents[agent_id].get("name", "Unknown Agent")
+                        return name
+        return None
+
+    def _get_sweep_animation(self, color_palette: list[str]) -> Text:
+        text = Text()
+        num_squares = self._sweep_num_squares
+        num_colors = len(color_palette)
+
+        offset = num_colors - 1
+        max_pos = (num_squares - 1) + offset
+        total_range = max_pos + offset
+        cycle_length = total_range * 2
+        frame_in_cycle = self._spinner_frame_index % cycle_length
+
+        wave_pos = total_range - abs(total_range - frame_in_cycle)
+        sweep_pos = wave_pos - offset
+
+        dot_color = "#0a3d1f"
+
+        for i in range(num_squares):
+            dist = abs(i - sweep_pos)
+            color_idx = max(0, num_colors - 1 - dist)
+
+            if color_idx == 0:
+                text.append("·", style=Style(color=dot_color))
+            else:
+                color = color_palette[color_idx]
+                text.append("▪", style=Style(color=color))
 
-        dot_count = self._agent_dot_states[agent_id]
-        dots = "." * dot_count
+        text.append(" ")
+        return text
 
-        return f"Waiting{dots}"
+    def _get_animated_verb_text(self, agent_id: str, verb: str) -> Text:  # noqa: ARG002
+        text = Text()
+        sweep = self._get_sweep_animation(self._sweep_colors)
+        text.append_text(sweep)
+        parts = verb.split(" ", 1)
+        text.append(parts[0], style="white")
+        if len(parts) > 1:
+            text.append(" ", style="dim")
+            text.append(parts[1], style="dim")
+        return text
 
     def _start_dot_animation(self) -> None:
         if self._dot_animation_timer is None:
-            self._dot_animation_timer = self.set_interval(0.6, self._animate_dots)
+            self._dot_animation_timer = self.set_interval(0.06, self._animate_dots)
 
     def _stop_dot_animation(self) -> None:
         if self._dot_animation_timer is not None:
@@ -749,29 +1312,53 @@ class StrixTUIApp(App):  # type: ignore[misc]
     def _animate_dots(self) -> None:
         has_active_agents = False
 
-        for agent_id, agent_data in self.tracer.agents.items():
+        if self.selected_agent_id and self.selected_agent_id in self.tracer.agents:
+            agent_data = self.tracer.agents[self.selected_agent_id]
             status = agent_data.get("status", "running")
             if status in ["running", "waiting"]:
                 has_active_agents = True
-                current_dots = self._agent_dot_states.get(agent_id, 0)
-                self._agent_dot_states[agent_id] = (current_dots + 1) % 4
-
-        if (
-            has_active_agents
-            and self.selected_agent_id
-            and self.selected_agent_id in self.tracer.agents
-        ):
-            selected_status = self.tracer.agents[self.selected_agent_id].get("status", "running")
-            if selected_status in ["running", "waiting"]:
+                num_colors = len(self._sweep_colors)
+                offset = num_colors - 1
+                max_pos = (self._sweep_num_squares - 1) + offset
+                total_range = max_pos + offset
+                cycle_length = total_range * 2
+                self._spinner_frame_index = (self._spinner_frame_index + 1) % cycle_length
                 self._update_agent_status_display()
 
+        if not has_active_agents:
+            has_active_agents = any(
+                agent_data.get("status", "running") in ["running", "waiting"]
+                for agent_data in self.tracer.agents.values()
+            )
+
         if not has_active_agents:
             self._stop_dot_animation()
-            for agent_id in list(self._agent_dot_states.keys()):
-                if agent_id not in self.tracer.agents or self.tracer.agents[agent_id].get(
-                    "status"
-                ) not in ["running", "waiting"]:
-                    del self._agent_dot_states[agent_id]
+            self._spinner_frame_index = 0
+
+    def _agent_has_real_activity(self, agent_id: str) -> bool:
+        initial_tools = {"scan_start_info", "subagent_start_info"}
+
+        for _exec_id, tool_data in list(self.tracer.tool_executions.items()):
+            if tool_data.get("agent_id") == agent_id:
+                tool_name = tool_data.get("tool_name", "")
+                if tool_name not in initial_tools:
+                    return True
+
+        streaming = self.tracer.get_streaming_content(agent_id)
+        return bool(streaming and streaming.strip())
+
+    def _agent_vulnerability_count(self, agent_id: str) -> int:
+        count = 0
+        for _exec_id, tool_data in list(self.tracer.tool_executions.items()):
+            if tool_data.get("agent_id") == agent_id:
+                tool_name = tool_data.get("tool_name", "")
+                if tool_name == "create_vulnerability_report":
+                    status = tool_data.get("status", "")
+                    if status == "completed":
+                        result = tool_data.get("result", {})
+                        if isinstance(result, dict) and result.get("success"):
+                            count += 1
+        return count
 
     def _gather_agent_events(self, agent_id: str) -> list[dict[str, Any]]:
         chat_events = [
@@ -792,7 +1379,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
                 "id": f"tool_{exec_id}",
                 "data": tool_data,
             }
-            for exec_id, tool_data in self.tracer.tool_executions.items()
+            for exec_id, tool_data in list(self.tracer.tool_executions.items())
             if tool_data.get("agent_id") == agent_id
         ]
 
@@ -871,10 +1458,9 @@ class StrixTUIApp(App):  # type: ignore[misc]
         }
 
         status_icon = status_indicators.get(status, "🔵")
-        agent_name = f"{status_icon} {escape_markup(agent_name_raw)}"
-
-        if status in ["running", "waiting"]:
-            self._start_agent_verb_timer(agent_id)
+        vuln_count = self._agent_vulnerability_count(agent_id)
+        vuln_indicator = f" ({vuln_count})" if vuln_count > 0 else ""
+        agent_name = f"{status_icon} {agent_name_raw}{vuln_indicator}"
 
         try:
             if parent_id and parent_id in self.agent_nodes:
@@ -904,6 +1490,13 @@ class StrixTUIApp(App):  # type: ignore[misc]
 
             logging.warning(f"Failed to add agent node {agent_id}: {e}")
 
+    def _expand_new_agent_nodes(self) -> None:
+        if len(self.screen_stack) > 1 or self.show_splash:
+            return
+
+        if not self.is_mounted:
+            return
+
     def _expand_all_agent_nodes(self) -> None:
         if len(self.screen_stack) > 1 or self.show_splash:
             return
@@ -939,7 +1532,9 @@ class StrixTUIApp(App):  # type: ignore[misc]
         }
 
         status_icon = status_indicators.get(status, "🔵")
-        agent_name = f"{status_icon} {escape_markup(agent_name_raw)}"
+        vuln_count = self._agent_vulnerability_count(agent_id)
+        vuln_indicator = f" ({vuln_count})" if vuln_count > 0 else ""
+        agent_name = f"{status_icon} {agent_name_raw}{vuln_indicator}"
 
         new_node = new_parent.add(
             agent_name,
@@ -958,7 +1553,7 @@ class StrixTUIApp(App):  # type: ignore[misc]
     def _reorganize_orphaned_agents(self, new_parent_id: str) -> None:
         agents_to_move = []
 
-        for agent_id, agent_data in self.tracer.agents.items():
+        for agent_id, agent_data in list(self.tracer.agents.items()):
             if (
                 agent_data.get("parent_id") == new_parent_id
                 and agent_id in self.agent_nodes
@@ -983,90 +1578,99 @@ class StrixTUIApp(App):  # type: ignore[misc]
                 old_node.remove()
 
         parent_node.allow_expand = True
-        self._expand_all_agent_nodes()
+        parent_node.expand()
 
-    def _render_chat_content(self, msg_data: dict[str, Any]) -> str:
+    def _render_chat_content(self, msg_data: dict[str, Any]) -> Any:
         role = msg_data.get("role")
-        content = escape_markup(msg_data.get("content", ""))
+        content = msg_data.get("content", "")
+        metadata = msg_data.get("metadata", {})
 
         if not content:
-            return ""
+            return None
 
         if role == "user":
             from strix.interface.tool_components.user_message_renderer import UserMessageRenderer
 
             return UserMessageRenderer.render_simple(content)
-        return content
 
-    def _render_tool_content_simple(self, tool_data: dict[str, Any]) -> str:
+        if metadata.get("interrupted"):
+            streaming_result = self._render_streaming_content(content)
+            interrupted_text = Text()
+            interrupted_text.append("\n")
+            interrupted_text.append("⚠ ", style="yellow")
+            interrupted_text.append("Interrupted by user", style="yellow dim")
+            return Group(streaming_result, interrupted_text)
+
+        from strix.interface.tool_components.agent_message_renderer import AgentMessageRenderer
+
+        return AgentMessageRenderer.render_simple(content)
+
+    def _render_tool_content_simple(self, tool_data: dict[str, Any]) -> Any:
         tool_name = tool_data.get("tool_name", "Unknown Tool")
         args = tool_data.get("args", {})
         status = tool_data.get("status", "unknown")
         result = tool_data.get("result")
 
-        tool_colors = {
-            "terminal_execute": "#22c55e",
-            "browser_action": "#06b6d4",
-            "python_action": "#3b82f6",
-            "agents_graph_action": "#fbbf24",
-            "file_edit_action": "#10b981",
-            "proxy_action": "#06b6d4",
-            "notes_action": "#fbbf24",
-            "thinking_action": "#a855f7",
-            "web_search_action": "#22c55e",
-            "finish_action": "#dc2626",
-            "reporting_action": "#ea580c",
-            "scan_start_info": "#22c55e",
-            "subagent_start_info": "#22c55e",
-            "llm_error_details": "#dc2626",
-        }
-
-        color = tool_colors.get(tool_name, "#737373")
-
         from strix.interface.tool_components.registry import get_tool_renderer
 
         renderer = get_tool_renderer(tool_name)
 
         if renderer:
             widget = renderer.render(tool_data)
-            content = str(widget.renderable)
-        elif tool_name == "llm_error_details":
-            lines = ["[red]✗ LLM Request Failed[/red]"]
-            if args.get("details"):
-                details = args["details"]
-                if len(details) > 300:
-                    details = details[:297] + "..."
-                lines.append(f"[dim]Details:[/dim] {escape_markup(details)}")
-            content = "\n".join(lines)
-        else:
-            status_icons = {
-                "running": "[yellow]●[/yellow]",
-                "completed": "[green]✓[/green]",
-                "failed": "[red]✗[/red]",
-                "error": "[red]✗[/red]",
-            }
-            status_icon = status_icons.get(status, "[dim]○[/dim]")
+            return widget.renderable
 
-            lines = [f"→ Using tool [bold blue]{escape_markup(tool_name)}[/] {status_icon}"]
+        text = Text()
 
-            if args:
-                for k, v in list(args.items())[:2]:
-                    str_v = str(v)
-                    if len(str_v) > 80:
-                        str_v = str_v[:77] + "..."
-                    lines.append(f"  [dim]{k}:[/] {escape_markup(str_v)}")
+        if tool_name in ("llm_error_details", "sandbox_error_details"):
+            return self._render_error_details(text, tool_name, args)
 
-            if status in ["completed", "failed", "error"] and result:
-                result_str = str(result)
-                if len(result_str) > 150:
-                    result_str = result_str[:147] + "..."
-                lines.append(f"[bold]Result:[/] {escape_markup(result_str)}")
+        text.append("→ Using tool ")
+        text.append(tool_name, style="bold blue")
 
-            content = "\n".join(lines)
+        status_styles = {
+            "running": ("●", "yellow"),
+            "completed": ("✓", "green"),
+            "failed": ("✗", "red"),
+            "error": ("✗", "red"),
+        }
+        icon, style = status_styles.get(status, ("○", "dim"))
+        text.append(" ")
+        text.append(icon, style=style)
+
+        if args:
+            for k, v in list(args.items())[:5]:
+                str_v = str(v)
+                if len(str_v) > 500:
+                    str_v = str_v[:497] + "..."
+                text.append("\n  ")
+                text.append(k, style="dim")
+                text.append(": ")
+                text.append(str_v)
+
+        if status in ["completed", "failed", "error"] and result:
+            result_str = str(result)
+            if len(result_str) > 1000:
+                result_str = result_str[:997] + "..."
+            text.append("\n")
+            text.append("Result: ", style="bold")
+            text.append(result_str)
 
-        lines = content.split("\n")
-        bordered_lines = [f"[{color}]▍[/{color}] {line}" for line in lines]
-        return "\n".join(bordered_lines)
+        return text
+
+    def _render_error_details(self, text: Any, tool_name: str, args: dict[str, Any]) -> Any:
+        if tool_name == "llm_error_details":
+            text.append("✗ LLM Request Failed", style="red")
+        else:
+            text.append("✗ Sandbox Initialization Failed", style="red")
+            if args.get("error"):
+                text.append(f"\n{args['error']}", style="bold red")
+        if args.get("details"):
+            details = str(args["details"])
+            if len(details) > 1000:
+                details = details[:997] + "..."
+            text.append("\nDetails: ", style="dim")
+            text.append(details)
+        return text
 
     @on(Tree.NodeHighlighted)  # type: ignore[misc]
     def handle_tree_highlight(self, event: Tree.NodeHighlighted) -> None:
@@ -1088,10 +1692,48 @@ class StrixTUIApp(App):  # type: ignore[misc]
             if agent_id:
                 self.selected_agent_id = agent_id
 
+    @on(Tree.NodeSelected)  # type: ignore[misc]
+    def handle_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        if len(self.screen_stack) > 1 or self.show_splash:
+            return
+
+        if not self.is_mounted:
+            return
+
+        node = event.node
+
+        if node.allow_expand:
+            if node.is_expanded:
+                node.collapse()
+            else:
+                node.expand()
+
     def _send_user_message(self, message: str) -> None:
         if not self.selected_agent_id:
             return
 
+        if self.tracer:
+            streaming_content = self.tracer.get_streaming_content(self.selected_agent_id)
+            if streaming_content and streaming_content.strip():
+                self.tracer.clear_streaming_content(self.selected_agent_id)
+                self.tracer.interrupted_content[self.selected_agent_id] = streaming_content
+                self.tracer.log_chat_message(
+                    content=streaming_content,
+                    role="assistant",
+                    agent_id=self.selected_agent_id,
+                    metadata={"interrupted": True},
+                )
+
+        try:
+            from strix.tools.agents_graph.agents_graph_actions import _agent_instances
+
+            if self.selected_agent_id in _agent_instances:
+                agent_instance = _agent_instances[self.selected_agent_id]
+                if hasattr(agent_instance, "cancel_current_execution"):
+                    agent_instance.cancel_current_execution()
+        except (ImportError, AttributeError, KeyError):
+            pass
+
         if self.tracer:
             self.tracer.log_chat_message(
                 content=message,
@@ -1159,12 +1801,14 @@ class StrixTUIApp(App):  # type: ignore[misc]
         self.push_screen(QuitScreen())
 
     def action_stop_selected_agent(self) -> None:
-        if (
-            self.show_splash
-            or not self.is_mounted
-            or len(self.screen_stack) > 1
-            or not self.selected_agent_id
-        ):
+        if self.show_splash or not self.is_mounted:
+            return
+
+        if len(self.screen_stack) > 1:
+            self.pop_screen()
+            return
+
+        if not self.selected_agent_id:
             return
 
         agent_name, should_stop = self._validate_agent_for_stopping()
@@ -1224,9 +1868,6 @@ class StrixTUIApp(App):  # type: ignore[misc]
             logging.exception(f"Failed to stop agent {agent_id}")
 
     def action_custom_quit(self) -> None:
-        for agent_id in list(self._agent_verb_timers.keys()):
-            self._stop_agent_verb_timer(agent_id)
-
         if self._scan_thread and self._scan_thread.is_alive():
             self._scan_stop_event.set()
 
@@ -1254,18 +1895,22 @@ class StrixTUIApp(App):  # type: ignore[misc]
         else:
             return True
 
-    def _update_static_content_safe(self, widget: Static, content: str) -> None:
+    def on_resize(self, event: events.Resize) -> None:
+        if self.show_splash or not self.is_mounted:
+            return
+
         try:
-            widget.update(content)
-        except Exception:  # noqa: BLE001
-            try:
-                safe_text = Text.from_markup(content)
-                widget.update(safe_text)
-            except Exception:  # noqa: BLE001
-                import re
+            sidebar = self.query_one("#sidebar", Vertical)
+            chat_area = self.query_one("#chat_area_container", Vertical)
+        except (ValueError, Exception):
+            return
 
-                plain_text = re.sub(r"\[.*?\]", "", content)
-                widget.update(plain_text)
+        if event.size.width < self.SIDEBAR_MIN_WIDTH:
+            sidebar.add_class("-hidden")
+            chat_area.add_class("-full-width")
+        else:
+            sidebar.remove_class("-hidden")
+            chat_area.remove_class("-full-width")
 
 
 async def run_tui(args: argparse.Namespace) -> None: