netra-zen 1.0.11__py3-none-any.whl → 1.2.0__py3-none-any.whl

{netra_zen-1.0.11.dist-info → netra_zen-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-zen
-Version: 1.0.11
+Version: 1.2.0
 Summary: Multi-instance Claude orchestrator for parallel task execution
 Home-page: https://github.com/netra-systems/zen
 Author:  Systems

{netra_zen-1.0.11.dist-info → netra_zen-1.2.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 zen_orchestrator.py,sha256=hKeP2dW6eJgEhtUHYylnhIgP_HgaxrDAwCnlS7mKkgU,156167
 agent_interface/__init__.py,sha256=OsbOKzElHsxhVgak87oOx_u46QNgKmz-Reis-plAMwk,525
 agent_interface/base_agent.py,sha256=GNskG9VaZgno7X24lQTpFdxUoQE0yJHLh0UPFJvOPn4,11098
-netra_zen-1.0.11.dist-info/licenses/LICENSE.md,sha256=PZrP0UDn58i4LjV4zijIQTnsQPvWm4zq9Fet9i7qgwI,80
+netra_zen-1.2.0.dist-info/licenses/LICENSE.md,sha256=PZrP0UDn58i4LjV4zijIQTnsQPvWm4zq9Fet9i7qgwI,80
 scripts/__init__.py,sha256=r6jX6e9SaisREml6B7uDoV-_rzIW0_yQXMm6OhNgbIw,52
 scripts/__main__.py,sha256=NSqyN47EijNf7m_8QsoxeYevKYgH2sNtNPFZcwKWMs0,160
-scripts/agent_cli.py,sha256=nN_uVvvMvFznEeIo4aHx3hBpXov5BkloQHcC6quAGFE,338473
+scripts/agent_cli.py,sha256=ATQIWoVx7GthFV1WeiV6Co8PzoXYXhlJjOerU-JocJ0,345625
 scripts/agent_logs.py,sha256=ppseAtUCvS2N-iEDSUQh84I9Ov-gBEw5ElxYajNdpJs,11218
 scripts/bump_version.py,sha256=fjABzzRVXJ00CbYMpUIUMwcOHwafLYtFL6NvUga-i6M,4183
 scripts/demo_log_collection.py,sha256=5XladS8j4lz-jJdVzSeDSxopChqHKX7HLNJUzSWR40c,5623
@@ -23,8 +23,8 @@ zen/telemetry/__init__.py,sha256=zyH7YcK_eWxwaQZW0MRefu1bX5hEgfRljr_dsqNU-tw,452
 zen/telemetry/apex_telemetry.py,sha256=FAkiHXOuzZFL-51oYetTC4wbjCL5UH-qOghwcaaOVgE,9685
 zen/telemetry/embedded_credentials.py,sha256=z-j_TfuVIz3nX-Vvh4O6_iDQhtteEyQgfc-xSslVbXU,1716
 zen/telemetry/manager.py,sha256=Rdbpnjbjel9xZEJyvLqy2M-4amvkr80abRiWnqHghIQ,9980
-netra_zen-1.0.11.dist-info/METADATA,sha256=0NbAxCCoF9-SB30FfxA2lU0oo0da1XNtNvSHkrRZX9I,46284
-netra_zen-1.0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-netra_zen-1.0.11.dist-info/entry_points.txt,sha256=oDehCnPGZezG0m9ZWspxjHLHyQ3eERX87eojR4ljaRo,45
-netra_zen-1.0.11.dist-info/top_level.txt,sha256=OhiyXmoXftBijCF6ck-RS1dN2NBJv9wdd7kBG1Es7zA,77
-netra_zen-1.0.11.dist-info/RECORD,,
+netra_zen-1.2.0.dist-info/METADATA,sha256=sb-1CUEfEqK3rmHbqxqrNeMi4t5d_hZ34xhBoPT1a90,46283
+netra_zen-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+netra_zen-1.2.0.dist-info/entry_points.txt,sha256=oDehCnPGZezG0m9ZWspxjHLHyQ3eERX87eojR4ljaRo,45
+netra_zen-1.2.0.dist-info/top_level.txt,sha256=OhiyXmoXftBijCF6ck-RS1dN2NBJv9wdd7kBG1Es7zA,77
+netra_zen-1.2.0.dist-info/RECORD,,

scripts/agent_cli.py

@@ -216,7 +216,9 @@ EMOJI_FALLBACKS = {
     '🔥': '[HOT]',
     '💭': '[THOUGHT]',
     '📥': '[INPUT]',
-    '📤': '[OUTPUT]'
+    '📤': '[OUTPUT]',
+    '📍': '[ENV]',
+    '🔗': '[LINK]'
 }
 
 def detect_terminal_capabilities(override_mode: str = None) -> str:
@@ -1592,18 +1594,18 @@ def show_startup_banner(config):
         config: Config object containing environment, backend_url, and auth_url
     """
     print()
-    print("━" * 75)
-    print("🤖 Netra Agent CLI - Interactive Mode")
-    print("━" * 75)
+    print("=" * 75)
+    safe_console_print("🤖 Netra Agent CLI - Interactive Mode", display_mode=detect_terminal_capabilities())
+    print("=" * 75)
     print()
-    print(f"📍 Environment: {config.environment.value.upper()}")
+    safe_console_print(f"📍 Environment: {config.environment.value.upper()}", display_mode=detect_terminal_capabilities())
     print()
 
-    print("🔗 Endpoints: ")
+    safe_console_print("🔗 Endpoints: ", display_mode=detect_terminal_capabilities())
     print(f"Backend: {config.backend_url}")
     print(f"Auth: {config.auth_url}")
     print()
-    print("━" * 75)
+    print("=" * 75)
     print()
 
 
@@ -2881,17 +2883,49 @@ class WebSocketClient:
                         self.connected = True
                         return True
                     else:
-                        # Handshake failed - backend might be old version
+                        # Handshake failed - server not ready to process messages
                         self.debug.debug_print(
-                            "WARNING: Handshake failed - backend may not support thread agreement",
+                            "WARNING: Server handshake not completed - server not ready",
                             DebugLevel.BASIC,
                             style="yellow"
                         )
+                        self.debug.debug_print(
+                            "Server still completing lifecycle phases (Initialize → Authenticate → Handshake → Prepare → Processing)",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
 
-                        # Still mark as connected for backward compatibility
-                        # Old backends might work without the handshake
-                        self.connected = True
-                        return True
+                        # Wait briefly for server to complete its phases and retry
+                        safe_console_print("⏳ Waiting for server to complete initialization...", style="yellow",
+                                         json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+                        await asyncio.sleep(3.0)  # Give server time to reach PROCESSING phase
+
+                        # Retry handshake once more
+                        self.debug.debug_print(
+                            "Retrying handshake after delay...",
+                            DebugLevel.VERBOSE,
+                            style="cyan"
+                        )
+                        handshake_success = await self._perform_handshake()
+                        if handshake_success:
+                            safe_console_print(f"✅ Connected with thread ID: {self.current_thread_id}", style="green",
+                                             json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+                            self.connected = True
+                            return True
+                        else:
+                            # Server still not ready - fail the connection
+                            self.debug.debug_print(
+                                "ERROR: Server not ready after retry",
+                                DebugLevel.BASIC,
+                                style="red"
+                            )
+                            safe_console_print("❌ Server not ready to process messages. Please try again.", style="red",
+                                             json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
+                            # Close WebSocket and fail gracefully
+                            if self.ws:
+                                await self.ws.close()
+                            return False
             except Exception as e:
                 self.debug.log_connection_attempt(method_name, self.config.ws_url, success=False, error=str(e))
                 self.debug.debug_print(
@@ -2997,77 +3031,150 @@ class WebSocketClient:
 
     async def _perform_handshake(self) -> bool:
         """
-        SSOT: Perform handshake protocol to get backend-provided thread_id.
-        This ensures both CLI and backend agree on the thread_id for proper event routing.
+        Wait for proactive handshake from server (as of 2025-10-09).
 
-        Protocol:
-        1. Client sends handshake_request with client info
-        2. Backend responds with handshake_response containing thread_id and session info
-        3. Client extracts thread_id and sends session_acknowledged
+        Server Phase Alignment:
+        - INITIALIZING: WebSocket connection accepted
+        - AUTHENTICATING: User validation (happens during connect())
+        - HANDSHAKING: Server proactively sends handshake_response (we wait here)
+        - READY: Services initialized
+        - PROCESSING: Message handling begins
 
-        The handshake_response is distinct from connection_established to avoid
-        race conditions and clearly separate WebSocket connection from session handshake.
+        The client waits during server's HANDSHAKING phase to receive the
+        proactive handshake_response without sending any request.
         """
         try:
             import asyncio
 
             self.debug.debug_print(
-                "Starting handshake...",
+                "Waiting for server to enter HANDSHAKING phase and send handshake...",
                 DebugLevel.VERBOSE,
                 style="cyan"
             )
 
-            # Try to receive immediately (backend may send immediately)
+            # Server enters HANDSHAKING phase after authentication
+            # and proactively sends handshake_response
+            # Use configured timeout or default to 10 seconds
+            handshake_timeout = self.handshake_timeout if hasattr(self, 'handshake_timeout') and self.handshake_timeout else 10.0
+            start_time = asyncio.get_event_loop().time()
+
             try:
-                # Non-blocking check if backend sent handshake_response immediately
-                # Use configurable timeout (default 2.0 seconds for initial check)
-                initial_timeout = min(2.0, self.handshake_timeout / 6)
-                response_msg = await asyncio.wait_for(self.ws.recv(), timeout=initial_timeout)
-                response = json.loads(response_msg)
-
-                # SSOT: Process any handshake-related response
-                return await self._process_any_handshake_response(response)
-            except asyncio.TimeoutError:
-                # Backend didn't send immediately, try sending a trigger message
-                pass  # Silent - this is normal for backends that wait for trigger
-
-            # If we didn't get handshake_response immediately, send a trigger
-            # This handles backends that wait for an initial message
-            trigger_message = {
-                "type": "handshake_request",
-                "client_type": "cli",
-                "client_version": "2.0.0",
-                "timestamp": datetime.now(timezone.utc).isoformat()
-            }
+                while (asyncio.get_event_loop().time() - start_time) < handshake_timeout:
+                    remaining_time = handshake_timeout - (asyncio.get_event_loop().time() - start_time)
 
-            self.debug.debug_print(
-                "Sending handshake_request...",
-                DebugLevel.VERBOSE,
-                style="cyan"
-            )
+                    # Be ready to receive messages during server's HANDSHAKING phase
+                    self.debug.debug_print(
+                        f"Listening for handshake (remaining: {remaining_time:.1f}s)...",
+                        DebugLevel.VERBOSE,
+                        style="dim"
+                    )
 
-            await self.ws.send(json.dumps(trigger_message))
+                    try:
+                        # Use the full remaining time for recv to avoid timeout errors
+                        # This prevents premature connection closure during handshake
+                        response_msg = await asyncio.wait_for(
+                            self.ws.recv(),
+                            timeout=remaining_time
+                        )
+                        response = json.loads(response_msg)
+                    except asyncio.TimeoutError:
+                        # Gracefully handle timeout - don't let it propagate and close connection
+                        self.debug.debug_print(
+                            "Handshake wait timed out after 10 seconds",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
+                        break  # Exit loop to handle timeout below
+                    except json.JSONDecodeError as e:
+                        # Handle JSON parsing errors gracefully
+                        self.debug.debug_print(
+                            f"Invalid JSON received during handshake: {e}",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
+                        continue  # Try to receive next message
+                    except websockets.exceptions.ConnectionClosed as e:
+                        # Connection closed during handshake - this is the issue!
+                        self.debug.debug_print(
+                            f"Connection closed during handshake wait: {e}",
+                            DebugLevel.BASIC,
+                            style="red"
+                        )
+                        return False  # Connection lost, can't continue
 
-            # Now wait for the response
-            try:
-                # Use configurable handshake timeout for main wait
-                response_msg = await asyncio.wait_for(self.ws.recv(), timeout=self.handshake_timeout)
-                response = json.loads(response_msg)
+                    msg_type = response.get('type', 'unknown')
+                    self.debug.debug_print(
+                        f"Received: {msg_type}",
+                        DebugLevel.VERBOSE,
+                        style="cyan"
+                    )
+
+                    # Check for the proactive handshake_response
+                    if msg_type == 'handshake_response':
+                        # Server is in HANDSHAKING phase and sent the handshake
+                        self.debug.debug_print(
+                            "✅ Server sent proactive handshake (HANDSHAKING phase)",
+                            DebugLevel.VERBOSE,
+                            style="green"
+                        )
 
-                # SSOT: Process any handshake-related response
-                return await self._process_any_handshake_response(response)
+                        # Process the handshake
+                        result = await self._process_handshake_response(response)
+
+                        if result:
+                            self.debug.debug_print(
+                                f"Handshake complete - Thread ID: {self.current_thread_id}",
+                                DebugLevel.BASIC,
+                                style="green"
+                            )
+                            self.debug.debug_print(
+                                "Server phases: AUTH ✓ → HANDSHAKING ✓ → READY",
+                                DebugLevel.VERBOSE,
+                                style="green"
+                            )
+
+                        return result
+
+                    # Handle other message types while waiting
+                    elif msg_type == 'connection_established':
+                        # This is from AUTHENTICATING phase completion
+                        self.debug.debug_print(
+                            "Connection established (AUTH phase) - waiting for HANDSHAKING phase",
+                            DebugLevel.VERBOSE,
+                            style="yellow"
+                        )
+                        # Store the event but continue waiting
+                        if hasattr(self, 'events'):
+                            self.events.append(WebSocketEvent.from_dict(response))
+
+                    else:
+                        # Other event types - store but keep waiting for handshake
+                        self.debug.debug_print(
+                            f"Storing {msg_type} event - still waiting for handshake",
+                            DebugLevel.VERBOSE,
+                            style="dim"
+                        )
+                        if hasattr(self, 'events'):
+                            self.events.append(WebSocketEvent.from_dict(response))
 
             except asyncio.TimeoutError:
-                # Timeout - log error concisely
-                self.debug.debug_print(
-                    "ERROR: Handshake timeout - no response from backend",
-                    DebugLevel.BASIC,
-                    style="red"
-                )
-                return False
+                pass  # Fall through to timeout handling below
+
+            # Timeout - server didn't send handshake
+            self.debug.debug_print(
+                "ERROR: Server did not send handshake within 10 seconds",
+                DebugLevel.BASIC,
+                style="red"
+            )
+            self.debug.debug_print(
+                "Server may not have HANDSHAKING phase (pre-2025-10-09 version)",
+                DebugLevel.BASIC,
+                style="yellow"
+            )
+            return False
 
         except Exception as e:
-            # Handshake error - log but don't completely fail
+            # Handshake error
             error_msg = f"WARNING: Handshake error: {e}"
             self.debug.log_error(e, "handshake protocol")
             self.debug.debug_print(error_msg, DebugLevel.BASIC, style="yellow")
@@ -3100,51 +3207,29 @@ class WebSocketClient:
             return await self._process_handshake_response(response)
 
         elif response_type == 'connection_established':
-            # Backend sends connection_established with connection_id as thread identifier
+            # connection_established is NOT a handshake response!
+            # It's just a WebSocket connection event. We should NOT acknowledge it.
+            # We need to wait for the actual handshake_response message.
             self.debug.debug_print(
-                "Processing connection_established as handshake response",
+                "Received connection_established - waiting for handshake_response",
                 DebugLevel.VERBOSE,
-                style="green"
+                style="yellow"
             )
 
-            # Extract connection_id from the data field and use as thread_id
+            # Extract connection_id for logging purposes only
             connection_data = response.get('data', {})
             connection_id = connection_data.get('connection_id')
 
-            if not connection_id:
+            if connection_id:
                 self.debug.debug_print(
-                    "ERROR: connection_established missing connection_id",
-                    DebugLevel.BASIC,
-                    style="red"
+                    f"Connection established with connection_id: {connection_id} (not using as thread_id)",
+                    DebugLevel.VERBOSE,
+                    style="yellow"
                 )
-                return False
-
-            # Use connection_id as thread_id (SSOT for thread identification)
-            self.current_thread_id = connection_id
-            self.run_id = connection_id  # Also use as run_id
-            self._update_thread_cache(connection_id)
-
-            self.debug.debug_print(
-                f"Handshake complete - Using connection_id as thread ID: {connection_id}",
-                DebugLevel.VERBOSE,
-                style="green"
-            )
-
-            # Send acknowledgment with the connection_id
-            ack_message = {
-                "type": "session_acknowledged",
-                "thread_id": connection_id,
-                "timestamp": datetime.now(timezone.utc).isoformat()
-            }
 
-            await self.ws.send(json.dumps(ack_message))
-            self.debug.debug_print(
-                f"Sent session_acknowledged with thread_id: {connection_id}",
-                DebugLevel.VERBOSE,
-                style="cyan"
-            )
-
-            return True
+            # Return False to indicate we're still waiting for handshake_response
+            # DO NOT send session_acknowledged here!
+            return False
 
         else:
             # Unexpected response type
@@ -3217,14 +3302,64 @@ class WebSocketClient:
             )
 
         # CRITICAL: Send acknowledgment with the SAME thread_id
+        # Per WebSocket Client Lifecycle Guide, use "handshake_acknowledged"
         ack_message = {
-            "type": "session_acknowledged",
+            "type": "handshake_acknowledged",
             "thread_id": backend_thread_id,  # Echo back the same ID
             "timestamp": datetime.now(timezone.utc).isoformat()
         }
 
         await self.ws.send(json.dumps(ack_message))
 
+        # Per WebSocket Client Lifecycle Guide, wait for handshake_complete
+        # and then add delay for server to enter Phase 5 (Processing)
+        self.debug.debug_print(
+            "Waiting for handshake_complete confirmation...",
+            DebugLevel.VERBOSE,
+            style="cyan"
+        )
+
+        # Wait briefly for handshake_complete message
+        try:
+            complete_msg = await asyncio.wait_for(self.ws.recv(), timeout=2.0)
+            complete_data = json.loads(complete_msg)
+            if complete_data.get('type') == 'handshake_complete':
+                self.debug.debug_print(
+                    "✅ Received handshake_complete - Server at Phase 4 (Ready)",
+                    DebugLevel.VERBOSE,
+                    style="green"
+                )
+
+                # CRITICAL: Add delay for server to enter Phase 5 (Processing)
+                # Per documentation, 500ms is recommended
+                self.debug.debug_print(
+                    "Waiting 500ms for server to enter Phase 5 (Processing)...",
+                    DebugLevel.VERBOSE,
+                    style="cyan"
+                )
+                await asyncio.sleep(0.5)
+
+                self.debug.debug_print(
+                    "✅ Server should now be in Phase 5 (Processing) - ready for messages",
+                    DebugLevel.VERBOSE,
+                    style="green"
+                )
+        except asyncio.TimeoutError:
+            # If no handshake_complete, still add a delay to be safe
+            self.debug.debug_print(
+                "No handshake_complete received, adding safety delay",
+                DebugLevel.VERBOSE,
+                style="yellow"
+            )
+            await asyncio.sleep(0.5)
+        except Exception as e:
+            self.debug.debug_print(
+                f"Error waiting for handshake_complete: {e}",
+                DebugLevel.VERBOSE,
+                style="yellow"
+            )
+            await asyncio.sleep(0.5)
+
         return True
 
     def _get_platform_cache_path(self) -> Path:
@@ -3565,6 +3700,27 @@ class WebSocketClient:
         if not self.ws:
             raise RuntimeError("WebSocket not connected")
 
+        # Check if connection handshake is fully complete
+        if not self.connected:
+            self.debug.debug_print(
+                "ERROR: Connection not ready - handshake not complete",
+                DebugLevel.BASIC,
+                style="red"
+            )
+            safe_console_print(
+                "\n❌ ERROR: Cannot send message - server not ready",
+                style="red",
+                json_mode=self.config.json_mode,
+                ci_mode=self.config.ci_mode
+            )
+            safe_console_print(
+                "The server is still completing its initialization phases.",
+                style="yellow",
+                json_mode=self.config.json_mode,
+                ci_mode=self.config.ci_mode
+            )
+            raise RuntimeError("Connection not ready - handshake incomplete. Server needs to reach Processing phase.")
+
         # Generate run_id
         self.run_id = f"cli_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}"
 
@@ -3810,9 +3966,9 @@ class WebSocketClient:
         # Check if payload exceeds maximum allowed size
         if payload_size_mb > MAX_SIZE_MB:
             error_msg = f"""
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                         ❌ PAYLOAD SIZE EXCEEDED                              ║
-╔══════════════════════════════════════════════════════════════════════════════╗
++==============================================================================+
+|                         ❌ PAYLOAD SIZE EXCEEDED                              |
++==============================================================================+
 
   Payload Size: {payload_size_mb:.2f} MB
   Maximum Allowed: {MAX_SIZE_MB:.1f} MB
@@ -3840,7 +3996,7 @@ class WebSocketClient:
 
 ✨ OPTIMAL PERFORMANCE: Keep payload under {OPTIMAL_SIZE_MB:.1f} MB for best results
 
-╚══════════════════════════════════════════════════════════════════════════════╝
++==============================================================================+
 """
             safe_console_print(error_msg, style="red")
             raise RuntimeError(f"Payload size ({payload_size_mb:.2f} MB) exceeds maximum allowed ({MAX_SIZE_MB:.1f} MB)")
@@ -3848,9 +4004,9 @@ class WebSocketClient:
         # Warn if payload is large but within limits
         if payload_size_mb > WARNING_SIZE_MB:
             warning_msg = f"""
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                      ⚠️  LARGE PAYLOAD WARNING                                ║
-╔══════════════════════════════════════════════════════════════════════════════╗
++==============================================================================+
+|                      ⚠️  LARGE PAYLOAD WARNING                                |
++==============================================================================+
 
   Payload Size: {payload_size_mb:.2f} MB
   Maximum Allowed: {MAX_SIZE_MB:.1f} MB
@@ -3875,7 +4031,7 @@ class WebSocketClient:
   • Keep total payload under {OPTIMAL_SIZE_MB:.1f} MB for best results
   • Larger payloads may take longer to process
 
-╚══════════════════════════════════════════════════════════════════════════════╝
++==============================================================================+
 """
             safe_console_print(warning_msg, style="yellow")
 
@@ -3910,7 +4066,16 @@ class WebSocketClient:
                     type=data.get('type', 'unknown'),
                     data=data
                 )
-                self.events.append(event)
+                # Skip duplicate connection_established events after handshake
+                if event.type == 'connection_established' and self.connected and self.current_thread_id:
+                    self.debug.debug_print(
+                        "Ignoring duplicate connection_established (already connected with thread_id)",
+                        DebugLevel.VERBOSE,
+                        style="yellow"
+                    )
+                    # Don't append duplicate connection events
+                else:
+                    self.events.append(event)
 
                 # Handle connection_established as a basic WebSocket connection event
                 # Note: handshake_response is now used for thread_id exchange, not connection_established
@@ -4781,51 +4946,47 @@ class AgentCLI:
 
     async def _receive_events(self):
         """Background task to receive and display events"""
-        thinking_spinner = None
-        thinking_live = None
+        # Create persistent spinner that stays at bottom
+        thinking_spinner = Progress(
+            SpinnerColumn(spinner_name="dots"),
+            TextColumn("[dim]{task.description}"),
+            console=Console(file=sys.stderr),
+            transient=True
+        )
+        thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
+        thinking_task = None
 
-        async def handle_event(event: WebSocketEvent):
-            nonlocal thinking_spinner, thinking_live
+        # Start the spinner live display
+        thinking_live.start()
 
-            # Stop spinner if it's running and we get any non-thinking/non-executing event
-            if thinking_live and event.type not in ["agent_thinking", "tool_executing"]:
-                thinking_live.stop()
-                thinking_live = None
-                thinking_spinner = None
+        async def handle_event(event: WebSocketEvent):
+            nonlocal thinking_task
 
             # Display event with enhanced formatting
             formatted_event = event.format_for_display(self.debug)
             safe_console_print(f"[{event.timestamp.strftime('%H:%M:%S')}] {formatted_event}")
 
-            # Start spinner for agent_thinking events (20-60 second wait indicator)
-            if event.type == "agent_thinking" and not thinking_live:
-                thought = event.data.get('thought', event.data.get('reasoning', ''))
-                spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+            # Update spinner for thinking and tool_executing events
+            if event.type in ["agent_thinking", "tool_executing"]:
+                # Remove old task if exists
+                if thinking_task is not None:
+                    thinking_spinner.remove_task(thinking_task)
+                    thinking_task = None
 
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[cyan]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
-
-            # Start spinner for tool_executing events
-            elif event.type == "tool_executing" and not thinking_live:
-                tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
-                spinner_text = f"Executing {tool_name}..."
-
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[blue]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+                # Add new task with latest event
+                if event.type == "agent_thinking":
+                    thought = event.data.get('thought', event.data.get('reasoning', ''))
+                    spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+                    thinking_task = thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
+                elif event.type == "tool_executing":
+                    tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
+                    spinner_text = f"Executing {tool_name}..."
+                    thinking_task = thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+
+            # Clear spinner for any other event type
+            elif thinking_task is not None:
+                thinking_spinner.remove_task(thinking_task)
+                thinking_task = None
 
             # Display raw data in verbose mode
             if self.debug.debug_level >= DebugLevel.DIAGNOSTIC:
@@ -4838,58 +4999,53 @@ class AgentCLI:
         try:
             await self.ws_client.receive_events(callback=handle_event)
         finally:
-            # Clean up spinner if it's still running
-            if thinking_live:
-                thinking_live.stop()
+            # Clean up spinner
+            thinking_live.stop()
 
     async def _receive_events_with_display(self):
         """ISSUE #1603 FIX: Enhanced event receiver with better display for single message mode"""
-        thinking_spinner = None
-        thinking_live = None
+        # Create persistent spinner that stays at bottom
+        thinking_spinner = Progress(
+            SpinnerColumn(spinner_name="dots"),
+            TextColumn("[dim]{task.description}"),
+            console=Console(file=sys.stderr),
+            transient=True
+        )
+        thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
+        thinking_task = None
 
-        async def handle_event_with_display(event: WebSocketEvent):
-            nonlocal thinking_spinner, thinking_live
+        # Start the spinner live display
+        thinking_live.start()
 
-            # Stop spinner if it's running and we get any non-thinking/non-executing event
-            if thinking_live and event.type not in ["agent_thinking", "tool_executing"]:
-                thinking_live.stop()
-                thinking_live = None
-                thinking_spinner = None
+        async def handle_event_with_display(event: WebSocketEvent):
+            nonlocal thinking_task
 
             # Display event with enhanced formatting and emojis
             formatted_event = event.format_for_display(self.debug)
             timestamp = event.timestamp.strftime('%H:%M:%S')
             safe_console_print(f"[{timestamp}] {formatted_event}")
 
-            # Start spinner for agent_thinking events (20-60 second wait indicator)
-            if event.type == "agent_thinking" and not thinking_live:
-                thought = event.data.get('thought', event.data.get('reasoning', ''))
-                spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+            # Update spinner for thinking and tool_executing events
+            if event.type in ["agent_thinking", "tool_executing"]:
+                # Remove old task if exists
+                if thinking_task is not None:
+                    thinking_spinner.remove_task(thinking_task)
+                    thinking_task = None
 
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[cyan]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
-
-            # Start spinner for tool_executing events
-            elif event.type == "tool_executing" and not thinking_live:
-                tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
-                spinner_text = f"Executing {tool_name}..."
-
-                thinking_spinner = Progress(
-                    SpinnerColumn(spinner_name="dots"),
-                    TextColumn("[blue]{task.description}"),
-                    console=Console(file=sys.stderr),
-                    transient=True
-                )
-                thinking_live = Live(thinking_spinner, console=Console(file=sys.stderr), refresh_per_second=10)
-                thinking_live.start()
-                thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+                # Add new task with latest event
+                if event.type == "agent_thinking":
+                    thought = event.data.get('thought', event.data.get('reasoning', ''))
+                    spinner_text = truncate_with_ellipsis(thought, 60) if thought else "Processing..."
+                    thinking_task = thinking_spinner.add_task(f"💭 {spinner_text}", total=None)
+                elif event.type == "tool_executing":
+                    tool_name = event.data.get('tool', event.data.get('tool_name', 'Unknown'))
+                    spinner_text = f"Executing {tool_name}..."
+                    thinking_task = thinking_spinner.add_task(f"🔧 {spinner_text}", total=None)
+
+            # Clear spinner for any other event type
+            elif thinking_task is not None:
+                thinking_spinner.remove_task(thinking_task)
+                thinking_task = None
 
             # Issue #2177: WebSocket event validation
             if self.validate_events and self.event_validator:
@@ -4969,9 +5125,8 @@ class AgentCLI:
         try:
             await self.ws_client.receive_events(callback=handle_event_with_display)
         finally:
-            # Clean up spinner if it's still running
-            if thinking_live:
-                thinking_live.stop()
+            # Clean up spinner
+            thinking_live.stop()
 
     def _get_event_summary(self, event: WebSocketEvent) -> str:
         """ISSUE #1603 FIX: Get a concise summary of an event for display"""