feat(ui): add live status updates during agent execution

Add real-time status messages to the TUI showing what each agent is
doing at any given moment. Previously agents showed only 'Initializing'
or a generic sweep animation.

Status messages now shown:
- 'Compressing memory...' during conversation history preparation
- 'Waiting for LLM provider...' during API call setup
- 'Generating response...' after first chunk received
- 'Executing {tool1}, {tool2} +N more...' during tool execution
- 'Setting up sandbox environment...' during sandbox init

Also fixes:
- Text span out-of-bounds crash when merging Rich Text renderables
- Thinking blocks now rendered in chat history from metadata
- Indented thought display in ThinkRenderer

Author: 0xhis

strix/agents/base_agent.py

@@ -321,6 +321,13 @@ async def _initialize_sandbox_and_state(self, task: str) -> None:
         sandbox_mode = os.getenv("STRIX_SANDBOX_MODE", "false").lower() == "true"
         if not sandbox_mode and self.state.sandbox_id is None:
             from strix.runtime import get_runtime
+            from strix.telemetry.tracer import get_global_tracer
+
+            tracer = get_global_tracer()
+            if tracer:
+                tracer.update_agent_system_message(
+                    self.state.agent_id, "Setting up sandbox environment..."
+                )
 
             try:
                 runtime = get_runtime()
@@ -355,6 +362,9 @@ async def _initialize_sandbox_and_state(self, task: str) -> None:
     async def _process_iteration(self, tracer: Optional["Tracer"]) -> bool:
         final_response = None
 
+        if tracer:
+            tracer.update_agent_system_message(self.state.agent_id, "Thinking...")
+
         async for response in self.llm.generate(self.state.get_conversation_history()):
             final_response = response
             if tracer and response.content:
@@ -396,8 +406,19 @@ async def _process_iteration(self, tracer: Optional["Tracer"]) -> bool:
         )
 
         if actions:
+            if tracer:
+                tool_names = [a.get("toolName") or a.get("tool_name") or "tool" for a in actions]
+                display_names = tool_names[:2]
+                overflow = len(tool_names) - 2
+                suffix = f" +{overflow} more" if overflow > 0 else ""
+                tracer.update_agent_system_message(
+                    self.state.agent_id, f"Executing {', '.join(display_names)}{suffix}..."
+                )
             return await self._execute_actions(actions, tracer)
 
+        if tracer:
+            tracer.update_agent_system_message(self.state.agent_id, "Processing response...")
+
         return False
 
     async def _execute_actions(self, actions: list[Any], tracer: Optional["Tracer"]) -> bool:

strix/interface/tool_components/thinking_renderer.py

@@ -23,7 +23,8 @@ def render(cls, tool_data: dict[str, Any]) -> Static:
         text.append("\n  ")
 
         if thought:
-            text.append(thought, style="italic dim")
+            indented_thought = "\n  ".join(thought.split("\n"))
+            text.append(indented_thought, style="italic dim")
         else:
             text.append("Thinking...", style="italic dim")
 

strix/interface/tui.py

@@ -1036,13 +1036,39 @@ def _merge_renderables(renderables: list[Any]) -> Text:
             if i > 0:
                 combined.append("\n")
             StrixTUIApp._append_renderable(combined, item)
-        return combined
+        return StrixTUIApp._sanitize_text_spans(combined)
+
+    @staticmethod
+    def _sanitize_text_spans(text: Text) -> Text:
+        plain = text.plain
+        plain_len = len(plain)
+
+        if plain_len == 0 or not text.spans:
+            return text
+
+        sanitized = Text(
+            plain,
+            style=text.style,
+            justify=text.justify,
+            overflow=text.overflow,
+            no_wrap=text.no_wrap,
+            end=text.end,
+            tab_size=text.tab_size,
+        )
+
+        for span in text.spans:
+            start = max(0, min(span.start, plain_len))
+            end = max(0, min(span.end, plain_len))
+            if end > start:
+                sanitized.stylize(span.style, start, end)
+
+        return sanitized
 
     @staticmethod
     def _append_renderable(combined: Text, item: Any) -> None:
         """Recursively append a renderable's text content to a combined Text."""
         if isinstance(item, Text):
-            combined.append_text(item)
+            combined.append_text(StrixTUIApp._sanitize_text_spans(item))
         elif isinstance(item, Group):
             for j, sub in enumerate(item.renderables):
                 if j > 0:
@@ -1087,7 +1113,7 @@ def _get_rendered_events_content(self, events: list[dict[str, Any]]) -> Any:
             return Text()
 
         if len(renderables) == 1 and isinstance(renderables[0], Text):
-            return renderables[0]
+            return self._sanitize_text_spans(renderables[0])
 
         return self._merge_renderables(renderables)
 
@@ -1123,7 +1149,7 @@ def _render_streaming_content(self, content: str, agent_id: str | None = None) -
         if not renderables:
             result = Text()
         elif len(renderables) == 1 and isinstance(renderables[0], Text):
-            result = renderables[0]
+            result = self._sanitize_text_spans(renderables[0])
         else:
             result = self._merge_renderables(renderables)
 
@@ -1215,14 +1241,19 @@ def keymap_styled(keys: list[tuple[str, str]]) -> Text:
             return (Text(" "), keymap, False)
 
         if status == "running":
+            sys_msg = agent_data.get("system_message", "")
             if self._agent_has_real_activity(agent_id):
                 animated_text = Text()
                 animated_text.append_text(self._get_sweep_animation(self._sweep_colors))
+                if sys_msg:
+                    animated_text.append(sys_msg, style="dim italic")
+                    animated_text.append("  ", style="dim")
                 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")
+            msg = sys_msg or "Initializing..."
+            animated_text = self._get_animated_verb_text(agent_id, msg)
             return (animated_text, keymap_styled([("ctrl-q", "quit")]), True)
 
         return (None, Text(), False)
@@ -1394,7 +1425,7 @@ def _animate_dots(self) -> None:
         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()
+                for agent_data in list(self.tracer.agents.values())
             )
 
         if not has_active_agents:
@@ -1655,12 +1686,26 @@ def _render_chat_content(self, msg_data: dict[str, Any]) -> Any:
         content = msg_data.get("content", "")
         metadata = msg_data.get("metadata", {})
 
-        if not content:
-            return None
-
         if role == "user":
+            if not content:
+                return None
             return UserMessageRenderer.render_simple(content)
 
+        renderables = []
+
+        if "thinking_blocks" in metadata and metadata["thinking_blocks"]:
+            from strix.interface.tool_components.thinking_renderer import ThinkRenderer
+
+            for block in metadata["thinking_blocks"]:
+                thought = block.get("thinking", "")
+                if thought:
+                    renderables.append(
+                        ThinkRenderer.render({"args": {"thought": thought}}).renderable
+                    )
+
+        if not content and not renderables:
+            return None
+
         if metadata.get("interrupted"):
             streaming_result = self._render_streaming_content(content)
             interrupted_text = Text()
@@ -1669,7 +1714,18 @@ def _render_chat_content(self, msg_data: dict[str, Any]) -> Any:
             interrupted_text.append("Interrupted by user", style="yellow dim")
             return self._merge_renderables([streaming_result, interrupted_text])
 
-        return AgentMessageRenderer.render_simple(content)
+        if content:
+            msg_renderable = AgentMessageRenderer.render_simple(content)
+            renderables.append(msg_renderable)
+
+        if not renderables:
+            return None
+
+        if len(renderables) == 1:
+            r = renderables[0]
+            return self._sanitize_text_spans(r) if isinstance(r, Text) else r
+
+        return self._merge_renderables(renderables)
 
     def _render_tool_content_simple(self, tool_data: dict[str, Any]) -> Any:
         tool_name = tool_data.get("tool_name", "Unknown Tool")

strix/llm/llm.py

@@ -112,12 +112,21 @@ def set_agent_identity(self, agent_name: str | None, agent_id: str | None) -> No
     async def generate(
         self, conversation_history: list[dict[str, Any]]
     ) -> AsyncIterator[LLMResponse]:
+        from strix.telemetry.tracer import get_global_tracer
+
+        tracer = get_global_tracer()
+        if tracer and self.agent_id:
+            tracer.update_agent_system_message(self.agent_id, "Compressing memory...")
+
         messages = self._prepare_messages(conversation_history)
         max_retries = int(Config.get("strix_llm_max_retries") or "5")
 
         for attempt in range(max_retries + 1):
             try:
-                async for response in self._stream(messages):
+                if tracer and self.agent_id:
+                    tracer.update_agent_system_message(self.agent_id, "Waiting for LLM provider...")
+
+                async for response in self._stream(messages, tracer):
                     yield response
                 return  # noqa: TRY300
             except Exception as e:  # noqa: BLE001
@@ -126,15 +135,23 @@ async def generate(
                 wait = min(10, 2 * (2**attempt))
                 await asyncio.sleep(wait)
 
-    async def _stream(self, messages: list[dict[str, Any]]) -> AsyncIterator[LLMResponse]:
+    async def _stream(
+        self, messages: list[dict[str, Any]], tracer: Any = None
+    ) -> AsyncIterator[LLMResponse]:
         accumulated = ""
         chunks: list[Any] = []
         done_streaming = 0
+        first_chunk_received = False
 
         self._total_stats.requests += 1
         response = await acompletion(**self._build_completion_args(messages), stream=True)
 
         async for chunk in response:
+            if not first_chunk_received:
+                first_chunk_received = True
+                if tracer and self.agent_id:
+                    tracer.update_agent_system_message(self.agent_id, "Generating response...")
+
             chunks.append(chunk)
             if done_streaming:
                 done_streaming += 1

strix/telemetry/tracer.py

@@ -189,6 +189,7 @@ def log_agent_creation(
             "name": name,
             "task": task,
             "status": "running",
+            "system_message": "",
             "parent_id": parent_id,
             "created_at": datetime.now(UTC).isoformat(),
             "updated_at": datetime.now(UTC).isoformat(),
@@ -260,6 +261,11 @@ def update_agent_status(
             if error_message:
                 self.agents[agent_id]["error_message"] = error_message
 
+    def update_agent_system_message(self, agent_id: str, message: str) -> None:
+        if agent_id in self.agents:
+            self.agents[agent_id]["system_message"] = message
+            self.agents[agent_id]["updated_at"] = datetime.now(UTC).isoformat()
+
     def set_scan_config(self, config: dict[str, Any]) -> None:
         self.scan_config = config
         self.run_metadata.update(