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

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

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

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

@@ -1,16 +1,22 @@
-zen_orchestrator.py,sha256=hKeP2dW6eJgEhtUHYylnhIgP_HgaxrDAwCnlS7mKkgU,156167
+zen_orchestrator.py,sha256=BcXb5hucuOq6OVlfWP6055SZEyMNpvW9dWeHmpOifGc,156153
 agent_interface/__init__.py,sha256=OsbOKzElHsxhVgak87oOx_u46QNgKmz-Reis-plAMwk,525
 agent_interface/base_agent.py,sha256=GNskG9VaZgno7X24lQTpFdxUoQE0yJHLh0UPFJvOPn4,11098
-netra_zen-1.2.0.dist-info/licenses/LICENSE.md,sha256=PZrP0UDn58i4LjV4zijIQTnsQPvWm4zq9Fet9i7qgwI,80
+netra_zen-1.2.3.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=ATQIWoVx7GthFV1WeiV6Co8PzoXYXhlJjOerU-JocJ0,345625
+scripts/agent_cli.py,sha256=SSsmoEzYhPfDpzHEtmTWf300kmd6_l5hL2EM3oygTuA,361760
 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
 scripts/embed_release_credentials.py,sha256=dEw3jP5Hvzbd0YUaXRZtiAZSpj315uVWIIjvwcK4g6Y,2103
 scripts/test_apex_telemetry_debug.py,sha256=UG5pbOmna653S9q83qPjrDAjkLeb6utW8ruXpWYy3aQ,6896
 scripts/verify_log_transmission.py,sha256=IZBeQos1rMHSdCyml_HL2x1XpLcpOuI0EUr0qA7mkE8,4493
+shared/README.md,sha256=BmZEHkMCddPKifIL4kEec6WNeX3t4gMp0Fmz8BJ3fC8,2024
+shared/TIMING_FIX_COMPLETE.md,sha256=KZUAF9OKFqYz7URs4unemNYYJXHFryhohc28c7P5250,3529
+shared/__init__.py,sha256=oE8UsFia6La8PUhngnjYeJuLD18SiT31sYFMmdXRwaI,412
+shared/windows_encoding.py,sha256=tAJ42LKsHKcbpRRKDYuRnPrxPovzwvkXjIavy1MNkcU,1395
+shared/types/__init__.py,sha256=_Ost84d4g3lg7p-MV4yZYiXU-fmJHlNEK4A1KWSzS1A,544
+shared/types/websocket_closure_codes.py,sha256=HY1UG_9tCK79PpI-b9sTmDiIrUtJsuDYwnEMlsuljmo,4429
 token_budget/__init__.py,sha256=_2tmi72DGNtbYcZ-rGIxVKMytdkHFjzJaWz8bDhYACc,33
 token_budget/budget_manager.py,sha256=VRWxKcGDtgJfIRh-ztYQ4-wuhBvddVJJnyoGfxCBlv0,9567
 token_budget/models.py,sha256=14xFTk2-R1Ql0F9WLDof7vADrKC_5Fj7EE7UmZdoG00,2384
@@ -21,10 +27,10 @@ zen/__init__.py,sha256=lVT1vB_ohU1o9-WRPwVsI2jtXB9mb7WaIdfDRfYC1PE,213
 zen/__main__.py,sha256=3Sex-j1o01NGoFnZOO9lPxcNX--M5VdIbjkJ_0z16qU,181
 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/embedded_credentials.py,sha256=bSU6XUOFQ7HP6TMOvuHfKz1Oo5v8pljneUjzwE8XprU,4941
 zen/telemetry/manager.py,sha256=Rdbpnjbjel9xZEJyvLqy2M-4amvkr80abRiWnqHghIQ,9980
-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,,
+netra_zen-1.2.3.dist-info/METADATA,sha256=VXUzXHtqJxTZNZEOoZi9nepmOjkPLE_-eEJDexwodE4,46283
+netra_zen-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+netra_zen-1.2.3.dist-info/entry_points.txt,sha256=oDehCnPGZezG0m9ZWspxjHLHyQ3eERX87eojR4ljaRo,45
+netra_zen-1.2.3.dist-info/top_level.txt,sha256=4TUOH4VJrzPxQU4XsvfaKC4_NdfZrFFsgQGbS_pMeX8,84
+netra_zen-1.2.3.dist-info/RECORD,,

{netra_zen-1.2.0.dist-info → netra_zen-1.2.3.dist-info}/top_level.txt

@@ -1,5 +1,6 @@
 agent_interface
 scripts
+shared
 token_budget
 token_transparency
 zen

scripts/agent_cli.py

@@ -9,6 +9,7 @@ import json
 import sys
 import os
 import argparse
+import time
 
 import logging
 
@@ -372,7 +373,7 @@ class DebugManager:
     Provides comprehensive debugging capabilities with different verbosity levels
     """
 
-    def __init__(self, debug_level: DebugLevel = DebugLevel.BASIC, log_file: Optional[Path] = None,
+    def __init__(self, debug_level: DebugLevel = DebugLevel.SILENT, log_file: Optional[Path] = None,
                  enable_websocket_diagnostics: bool = False, json_mode: bool = False, ci_mode: bool = False):
         self.debug_level = debug_level
         self.log_file = log_file or Path.home() / ".netra" / "cli_debug.log"
@@ -1628,7 +1629,7 @@ class Config:
     log_level: str = "INFO"
     timeout: int = 30
     default_email: str = "test@netra.ai"
-    debug_level: DebugLevel = DebugLevel.BASIC
+    debug_level: DebugLevel = DebugLevel.SILENT
     debug_log_file: Optional[Path] = None
     stream_logs: bool = False  # Issue #1828: Stream backend logs via WebSocket
     enable_websocket_diagnostics: bool = False  # Issue #2478: Enhanced WebSocket error diagnostics
@@ -2602,7 +2603,7 @@ class WebSocketClient:
     def __init__(self, config: Config, token: str, debug_manager: Optional[DebugManager] = None,
                  send_logs: bool = False, logs_count: int = 1, logs_project: Optional[str] = None,
                  logs_path: Optional[str] = None, logs_user: Optional[str] = None,
-                 handshake_timeout: float = 2.0):
+                 handshake_timeout: float = 10.0):
         self.config = config
         self.token = token
         self.debug = debug_manager or DebugManager(config.debug_level, config.debug_log_file, config.enable_websocket_diagnostics)
@@ -2643,6 +2644,11 @@ class WebSocketClient:
         self.closure_reason: Optional[str] = None
         self.closure_category: Optional[WebSocketClosureCategory] = None
 
+        # Event queuing mechanism: Wait for BOTH handshake AND connection_established
+        self.connection_established_received = False
+        self.event_queue: List[Dict[str, Any]] = []
+        self.ready_to_send_events = False
+
     def _initialize_timeouts(self) -> None:
         """Initialize WebSocket timeouts using backend timeout configuration.
 
@@ -2863,16 +2869,16 @@ class WebSocketClient:
         for method_name, method in methods:
             try:
                 self.debug.debug_print(
-                    f"GOLDEN PATH TRACE: Initiating WebSocket auth via {method_name}",
-                    DebugLevel.BASIC,
+                    f"Initiating WebSocket auth via {method_name}",
+                    DebugLevel.VERBOSE,
                     style="cyan"
                 )
                 self.debug.log_connection_attempt(method_name, self.config.ws_url)
                 if await method():
                     self.debug.log_connection_attempt(method_name, self.config.ws_url, success=True)
                     self.debug.debug_print(
-                        f"GOLDEN PATH TRACE: WebSocket connected using {method_name}",
-                        DebugLevel.BASIC,
+                        f"WebSocket connected using {method_name}",
+                        DebugLevel.VERBOSE,
                         style="green"
                     )
 
@@ -2881,14 +2887,35 @@ class WebSocketClient:
                     if handshake_success:
                         safe_console_print(f"✅ Connected with thread ID: {self.current_thread_id}", style="green")
                         self.connected = True
+
+                        # Start listening for events in background immediately
+                        asyncio.create_task(self.receive_events())
+
+                        # Wait for connection_established event
+                        wait_start = asyncio.get_event_loop().time()
+                        timeout = 5.0
+                        while not self.connection_established_received:
+                            if (asyncio.get_event_loop().time() - wait_start) > timeout:
+                                self.debug.debug_print(
+                                    f"⚠️ Timeout waiting for connection_established after {timeout}s",
+                                    DebugLevel.BASIC,
+                                    style="yellow"
+                                )
+                                break
+                            await asyncio.sleep(0.1)
+
+                        # Set ready flag if we got the event
+                        if self.connection_established_received:
+                            self.ready_to_send_events = True
+                            self.debug.debug_print(
+                                "✅ Connection fully established - ready to send events",
+                                DebugLevel.BASIC,
+                                style="green"
+                            )
+
                         return True
                     else:
                         # Handshake failed - server not ready to process messages
-                        self.debug.debug_print(
-                            "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,
@@ -2911,6 +2938,32 @@ class WebSocketClient:
                             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
+
+                            # Start listening for events in background immediately
+                            asyncio.create_task(self.receive_events())
+
+                            # Wait for connection_established event
+                            wait_start = asyncio.get_event_loop().time()
+                            timeout = 5.0
+                            while not self.connection_established_received:
+                                if (asyncio.get_event_loop().time() - wait_start) > timeout:
+                                    self.debug.debug_print(
+                                        f"⚠️ Timeout waiting for connection_established after {timeout}s",
+                                        DebugLevel.BASIC,
+                                        style="yellow"
+                                    )
+                                    break
+                                await asyncio.sleep(0.1)
+
+                            # Set ready flag if we got the event
+                            if self.connection_established_received:
+                                self.ready_to_send_events = True
+                                self.debug.debug_print(
+                                    "✅ Connection fully established - ready to send events",
+                                    DebugLevel.BASIC,
+                                    style="green"
+                                )
+
                             return True
                         else:
                             # Server still not ready - fail the connection
@@ -2929,7 +2982,7 @@ class WebSocketClient:
             except Exception as e:
                 self.debug.log_connection_attempt(method_name, self.config.ws_url, success=False, error=str(e))
                 self.debug.debug_print(
-                    f"GOLDEN PATH TRACE: WebSocket authentication via {method_name} failed with {type(e).__name__}: {e}",
+                    f"WebSocket authentication via {method_name} failed with {type(e).__name__}: {e}",
                     DebugLevel.BASIC,
                     style="red"
                 )
@@ -3133,19 +3186,51 @@ class WebSocketClient:
                                 style="green"
                             )
 
+                            # Check if we can start sending events
+                            # We need BOTH handshake AND connection_established
+                            if self.connection_established_received:
+                                self.ready_to_send_events = True
+                                self.debug.debug_print(
+                                    "✅ Ready to send events: Handshake ✓ | connection_established ✓",
+                                    DebugLevel.BASIC,
+                                    style="green"
+                                )
+                                safe_console_print(
+                                    "✅ Fully connected: Handshake ✓ | connection_established ✓",
+                                    style="green",
+                                    json_mode=self.config.json_mode,
+                                    ci_mode=self.config.ci_mode
+                                )
+                            else:
+                                self.debug.debug_print(
+                                    "⏳ Handshake complete, waiting for connection_established event",
+                                    DebugLevel.BASIC,
+                                    style="yellow"
+                                )
+
                         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",
+                            "✓ Connection established (AUTH phase) - waiting for HANDSHAKING phase",
                             DebugLevel.VERBOSE,
                             style="yellow"
                         )
+                        # Track that connection_established was received
+                        self.connection_established_received = True
+                        self.debug.debug_print(
+                            "📌 connection_established event received during handshake",
+                            DebugLevel.BASIC,
+                            style="cyan"
+                        )
                         # Store the event but continue waiting
                         if hasattr(self, 'events'):
-                            self.events.append(WebSocketEvent.from_dict(response))
+                            self.events.append(WebSocketEvent(
+                                type=response.get('type', 'unknown'),
+                                data=response
+                            ))
 
                     else:
                         # Other event types - store but keep waiting for handshake
@@ -3155,20 +3240,18 @@ class WebSocketClient:
                             style="dim"
                         )
                         if hasattr(self, 'events'):
-                            self.events.append(WebSocketEvent.from_dict(response))
+                            self.events.append(WebSocketEvent(
+                                type=response.get('type', 'unknown'),
+                                data=response
+                            ))
 
             except asyncio.TimeoutError:
                 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,
+                "Server did not send handshake - may be using pre-2025-10-09 version without HANDSHAKING phase",
+                DebugLevel.VERBOSE,
                 style="yellow"
             )
             return False
@@ -3695,6 +3778,101 @@ class WebSocketClient:
 
         return False
 
+    async def _flush_queued_events(self) -> None:
+        """
+        Flush all queued events after connection_established is received.
+
+        This method sends all events that were queued while waiting for
+        the connection_established event (which comes after handshake).
+        """
+        if not self.event_queue:
+            self.debug.debug_print(
+                "No queued events to flush",
+                DebugLevel.VERBOSE,
+                style="dim"
+            )
+            return
+
+        queue_size = len(self.event_queue)
+        self.debug.debug_print(
+            f"🚀 Flushing {queue_size} queued event(s) after connection_established",
+            DebugLevel.BASIC,
+            style="green"
+        )
+        safe_console_print(
+            f"🚀 Connection fully established! Sending {queue_size} queued event(s)...",
+            style="green",
+            json_mode=self.config.json_mode,
+            ci_mode=self.config.ci_mode
+        )
+
+        # Send all queued events
+        for i, event_payload in enumerate(self.event_queue, 1):
+            try:
+                self.debug.debug_print(
+                    f"Sending queued event {i}/{queue_size}: {event_payload.get('type', 'unknown')}",
+                    DebugLevel.VERBOSE,
+                    style="cyan"
+                )
+                await self.ws.send(json.dumps(event_payload))
+                self.debug.debug_print(
+                    f"✓ Queued event {i}/{queue_size} sent successfully",
+                    DebugLevel.VERBOSE,
+                    style="green"
+                )
+            except Exception as e:
+                self.debug.log_error(e, f"sending queued event {i}/{queue_size}")
+                safe_console_print(
+                    f"⚠️ Failed to send queued event {i}/{queue_size}: {e}",
+                    style="yellow",
+                    json_mode=self.config.json_mode,
+                    ci_mode=self.config.ci_mode
+                )
+
+        # Clear the queue
+        self.event_queue.clear()
+        self.debug.debug_print(
+            f"✅ All {queue_size} queued events have been sent",
+            DebugLevel.BASIC,
+            style="green"
+        )
+
+    def _display_log_collection_info(self, info: dict) -> None:
+        """Display log collection information to the console"""
+        separator = "=" * 60
+
+        # Display log collection details
+        safe_console_print("", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(separator, style="cyan", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print("SENDING LOGS TO OPTIMIZER", style="bold cyan", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(separator, style="cyan", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(f"  Total Entries: {len(info['logs'])}", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(f"  Files Read: {info['files_read']}", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(f"  Payload Size: {info['size_str']}", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
+        if self.logs_project:
+            safe_console_print(f"  Project: {self.logs_project}", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
+        safe_console_print("", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print("  Files:", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
+        # Add file details with hashes
+        for file_info in info['file_info']:
+            safe_console_print(
+                f"    * {file_info['name']} (hash: {file_info['hash']}, {file_info['entries']} entries)",
+                json_mode=self.config.json_mode, ci_mode=self.config.ci_mode
+            )
+
+        # Add payload proof
+        safe_console_print("", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print("  Payload Confirmation:", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(f"    [OK] 'jsonl_logs' key added to payload", style="green", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(f"    [OK] First log entry timestamp: {info['logs'][0].get('timestamp', 'N/A') if info['logs'] else 'N/A'}", style="green", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print(f"    [OK] Last log entry timestamp: {info['logs'][-1].get('timestamp', 'N/A') if info['logs'] else 'N/A'}", style="green", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
+        safe_console_print(separator, style="cyan", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+        safe_console_print("", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
     async def send_message(self, message: str) -> str:
         """Send a message and return the run_id"""
         if not self.ws:
@@ -3721,6 +3899,75 @@ class WebSocketClient:
             )
             raise RuntimeError("Connection not ready - handshake incomplete. Server needs to reach Processing phase.")
 
+        # NEW: Check if ready to send events
+        # Events can only be sent AFTER both handshake AND connection_established
+        if not self.ready_to_send_events:
+            # Wait for connection_established event with timeout
+            self.debug.debug_print(
+                "⏳ Waiting for connection_established event before sending message...",
+                DebugLevel.BASIC,
+                style="yellow"
+            )
+            safe_console_print(
+                "⏳ Waiting for connection_established event (up to 5 seconds)...",
+                style="yellow",
+                json_mode=self.config.json_mode,
+                ci_mode=self.config.ci_mode
+            )
+
+            # Wait up to 30 seconds for connection_established
+            wait_timeout = 30.0
+            wait_start = time.time()
+            wait_interval = 0.1
+
+            while not self.ready_to_send_events and (time.time() - wait_start) < wait_timeout:
+                await asyncio.sleep(wait_interval)
+                # Check if connection_established arrived
+                if self.ready_to_send_events:
+                    self.debug.debug_print(
+                        "✅ connection_established received - ready to send events",
+                        DebugLevel.BASIC,
+                        style="green"
+                    )
+                    safe_console_print(
+                        "✅ connection_established received - proceeding with message",
+                        style="green",
+                        json_mode=self.config.json_mode,
+                        ci_mode=self.config.ci_mode
+                    )
+                    break
+
+            # If still not ready after timeout, then error
+            if not self.ready_to_send_events:
+                elapsed = time.time() - wait_start
+                self.debug.debug_print(
+                    f"❌ Timeout waiting for connection_established after {elapsed:.1f} seconds",
+                    DebugLevel.BASIC,
+                    style="red"
+                )
+                safe_console_print(
+                    f"❌ Timeout: connection_established event not received after {elapsed:.1f} seconds",
+                    style="red",
+                    json_mode=self.config.json_mode,
+                    ci_mode=self.config.ci_mode
+                )
+                safe_console_print(
+                    "   Handshake complete: ✓ | connection_established: ✗",
+                    style="dim",
+                    json_mode=self.config.json_mode,
+                    ci_mode=self.config.ci_mode
+                )
+                safe_console_print(
+                    "\n💡 The server may not be sending the connection_established event.",
+                    style="yellow",
+                    json_mode=self.config.json_mode,
+                    ci_mode=self.config.ci_mode
+                )
+                raise RuntimeError(
+                    f"Cannot send message - connection_established event not received after {elapsed:.1f}s timeout. "
+                    "Both handshake and connection_established are required before sending events."
+                )
+
         # Generate run_id
         self.run_id = f"cli_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}"
 
@@ -3843,51 +4090,13 @@ class WebSocketClient:
                     else:
                         size_str = f"{logs_size_bytes} bytes"
 
-                    # Create prominent, formatted log message
-                    separator = "=" * 60
-                    log_msg_parts = [
-                        "",
-                        separator,
-                        f"📤 SENDING LOGS TO OPTIMIZER",
-                        separator,
-                        f"  Total Entries: {len(logs)}",
-                        f"  Files Read: {files_read}",
-                        f"  Payload Size: {size_str}",
-                    ]
-
-                    if self.logs_project:
-                        log_msg_parts.append(f"  Project: {self.logs_project}")
-
-                    log_msg_parts.append("")
-                    log_msg_parts.append("  Files:")
-
-                    # Add file details with hashes
-                    for info in file_info:
-                        log_msg_parts.append(
-                            f"    • {info['name']} (hash: {info['hash']}, {info['entries']} entries)"
-                        )
-
-                    # Add payload proof
-                    log_msg_parts.append("")
-                    log_msg_parts.append("  Payload Confirmation:")
-                    log_msg_parts.append(f"    ✓ 'jsonl_logs' key added to payload")
-                    log_msg_parts.append(f"    ✓ First log entry timestamp: {logs[0].get('timestamp', 'N/A') if logs else 'N/A'}")
-                    log_msg_parts.append(f"    ✓ Last log entry timestamp: {logs[-1].get('timestamp', 'N/A') if logs else 'N/A'}")
-
-                    log_msg_parts.append(separator)
-                    log_msg_parts.append("")
-
-                    log_msg = "\n".join(log_msg_parts)
-
-                    # Log at INFO level
-                    logging.info(log_msg)
-
-                    # Also print via debug system for consistency
-                    self.debug.debug_print(
-                        log_msg,
-                        DebugLevel.BASIC,
-                        style="cyan"
-                    )
+                    # Save log display info for later (will be displayed after "Sending message:")
+                    self._log_display_info = {
+                        'logs': logs,
+                        'files_read': files_read,
+                        'file_info': file_info,
+                        'size_str': size_str
+                    }
                 else:
                     self.debug.debug_print(
                         "Warning: --send-logs enabled but no logs found",
@@ -3903,7 +4112,7 @@ class WebSocketClient:
                 )
 
         self.debug.debug_print(
-            f"GOLDEN PATH TRACE: Prepared WebSocket payload for run_id={self.run_id}, thread_id={thread_id}",
+            f"Prepared WebSocket payload for run_id={self.run_id}, thread_id={thread_id}",
             DebugLevel.BASIC,
             style="yellow"
         )
@@ -4039,6 +4248,15 @@ class WebSocketClient:
         if self.debug.debug_level >= DebugLevel.DIAGNOSTIC:
             self.debug.debug_print(f"SENDING WEBSOCKET MESSAGE: {json.dumps(payload, indent=2)}", DebugLevel.DIAGNOSTIC)
 
+        # Print sending message after logs section (moved from run_cli method)
+        safe_console_print(f"Sending message: {payload['payload']['content']}", style="cyan", json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
+        # Display log collection info after "Sending message:" if logs were collected
+        if self.send_logs and hasattr(self, '_log_display_info'):
+            self._display_log_collection_info(self._log_display_info)
+            # Clean up the temporary display info
+            del self._log_display_info
+
         await self.ws.send(payload_json)
         if self.debug.debug_level >= DebugLevel.VERBOSE:
             self.debug.debug_print(f"WEBSOCKET MESSAGE SENT SUCCESSFULLY - run_id: {self.run_id}, thread_id: {thread_id}", DebugLevel.VERBOSE)
@@ -4051,7 +4269,7 @@ class WebSocketClient:
 
         self.debug.debug_print("Listening for WebSocket events...")
         self.debug.debug_print(
-            "GOLDEN PATH TRACE: Event listener started after successful connection",
+            "Event listener started after successful connection",
             DebugLevel.BASIC,
             style="cyan"
         )
@@ -4080,15 +4298,43 @@ class WebSocketClient:
                 # Handle connection_established as a basic WebSocket connection event
                 # Note: handshake_response is now used for thread_id exchange, not connection_established
                 if event.type == 'connection_established':
-                    # This is now just a basic connection confirmation, not part of handshake
-                    self.debug.debug_print(
-                        f"WebSocket connection established event received",
-                        DebugLevel.VERBOSE,
-                        style="dim"
-                    )
+                    # Track that connection_established was received
+                    if not self.connection_established_received:
+                        self.connection_established_received = True
+                        self.debug.debug_print(
+                            "📌 connection_established event received after handshake",
+                            DebugLevel.BASIC,
+                            style="cyan"
+                        )
+
+                        # Check if we can now start sending events
+                        # We need BOTH handshake (self.connected) AND connection_established
+                        if self.connected and not self.ready_to_send_events:
+                            self.ready_to_send_events = True
+                            self.debug.debug_print(
+                                "✅ Ready to send events: Handshake ✓ | connection_established ✓",
+                                DebugLevel.BASIC,
+                                style="green"
+                            )
+                            safe_console_print(
+                                "✅ Fully connected: Handshake ✓ | connection_established ✓",
+                                style="green",
+                                json_mode=self.config.json_mode,
+                                ci_mode=self.config.ci_mode
+                            )
+
+                            # Flush any queued events
+                            await self._flush_queued_events()
+                    else:
+                        # This is a duplicate connection_established event
+                        self.debug.debug_print(
+                            f"WebSocket connection_established event received (duplicate, already tracked)",
+                            DebugLevel.VERBOSE,
+                            style="dim"
+                        )
 
                 self.debug.debug_print(
-                    f"GOLDEN PATH TRACE: Parsed WebSocket event type={event.type}",
+                    f"Parsed WebSocket event type={event.type}",
                     DebugLevel.BASIC,
                     style="green"
                 )
@@ -4758,7 +5004,7 @@ class AgentCLI:
                  json_mode: bool = False, ci_mode: bool = False, json_output_file: Optional[str] = None,
                  send_logs: bool = False, logs_count: int = 1, logs_project: Optional[str] = None,
                  logs_path: Optional[str] = None, logs_user: Optional[str] = None,
-                 handshake_timeout: float = 2.0):
+                 handshake_timeout: float = 10.0):
         # ISSUE #2766: Store JSON/CI mode flags early for output suppression
         self.json_mode = json_mode
         self.ci_mode = ci_mode
@@ -4966,8 +5212,8 @@ class AgentCLI:
             formatted_event = event.format_for_display(self.debug)
             safe_console_print(f"[{event.timestamp.strftime('%H:%M:%S')}] {formatted_event}")
 
-            # Update spinner for thinking and tool_executing events
-            if event.type in ["agent_thinking", "tool_executing"]:
+            # Update spinner for thinking and tool_executing events (if spinner is enabled)
+            if spinner_enabled and event.type in ["agent_thinking", "tool_executing"]:
                 # Remove old task if exists
                 if thinking_task is not None:
                     thinking_spinner.remove_task(thinking_task)
@@ -4983,8 +5229,8 @@ class AgentCLI:
                     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:
+            # Clear spinner for any other event type (if spinner is enabled)
+            elif spinner_enabled and thinking_task is not None:
                 thinking_spinner.remove_task(thinking_task)
                 thinking_task = None
 
@@ -5004,29 +5250,47 @@ class AgentCLI:
 
     async def _receive_events_with_display(self):
         """ISSUE #1603 FIX: Enhanced event receiver with better display for single message mode"""
+        # Debug: Confirm function is called
+        if self.debug.debug_level >= DebugLevel.SILENT:
+            safe_console_print("⏳ Waiting for agent response...", style="dim", json_mode=self.json_mode, ci_mode=self.ci_mode)
+
         # 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)
+        # Note: Using Console() without file parameter for better Windows compatibility
+        thinking_spinner = None
+        thinking_live = None
         thinking_task = None
+        spinner_enabled = False
+        event_count = 0  # Track number of events received
+        last_event_index = len(self.ws_client.events)  # Track where we are in the event list
 
-        # Start the spinner live display
-        thinking_live.start()
+        try:
+            thinking_spinner = Progress(
+                SpinnerColumn(spinner_name="dots"),
+                TextColumn("[dim]{task.description}"),
+                console=Console(),
+                transient=True
+            )
+            thinking_live = Live(thinking_spinner, console=Console(), refresh_per_second=10)
+            # Start the spinner live display
+            thinking_live.start()
+            spinner_enabled = True
+        except Exception as e:
+            # Spinner failed to start (common on Windows), continue without it
+            if self.debug.debug_level >= DebugLevel.SILENT:
+                safe_console_print(f"Note: Live spinner disabled ({str(e)[:50]})", style="dim yellow", json_mode=self.json_mode, ci_mode=self.ci_mode)
+            spinner_enabled = False
 
-        async def handle_event_with_display(event: WebSocketEvent):
-            nonlocal thinking_task
+        def handle_event_with_display(event: WebSocketEvent):
+            nonlocal thinking_task, event_count
+            event_count += 1
 
             # 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}")
+            safe_console_print(f"[{timestamp}] {formatted_event}", json_mode=self.json_mode, ci_mode=self.ci_mode)
 
-            # Update spinner for thinking and tool_executing events
-            if event.type in ["agent_thinking", "tool_executing"]:
+            # Update spinner for thinking and tool_executing events (if spinner is enabled)
+            if spinner_enabled and event.type in ["agent_thinking", "tool_executing"]:
                 # Remove old task if exists
                 if thinking_task is not None:
                     thinking_spinner.remove_task(thinking_task)
@@ -5042,8 +5306,8 @@ class AgentCLI:
                     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:
+            # Clear spinner for any other event type (if spinner is enabled)
+            elif spinner_enabled and thinking_task is not None:
                 thinking_spinner.remove_task(thinking_task)
                 thinking_task = None
 
@@ -5067,15 +5331,15 @@ class AgentCLI:
                 if event.type == "agent_thinking":
                     thought = event.data.get('thought', event.data.get('reasoning', ''))
                     if thought and len(thought) > 100:
-                        safe_console_print(f"💭 Full thought: {thought}", style="dim cyan")
+                        safe_console_print(f"💭 Full thought: {thought}", style="dim cyan", json_mode=self.json_mode, ci_mode=self.ci_mode)
                 elif event.type == "tool_executing":
                     tool_input = event.data.get('input', event.data.get('parameters', {}))
                     if tool_input:
-                        safe_console_print(f"📥 Tool input: {json.dumps(tool_input, indent=2)[:200]}...", style="dim blue")
+                        safe_console_print(f"📥 Tool input: {json.dumps(tool_input, indent=2)[:200]}...", style="dim blue", json_mode=self.json_mode, ci_mode=self.ci_mode)
                 elif event.type == "tool_completed":
                     tool_output = event.data.get('output', event.data.get('result', ''))
                     if tool_output:
-                        safe_console_print(f"📤 Tool output: {str(tool_output)[:200]}...", style="dim green")
+                        safe_console_print(f"📤 Tool output: {str(tool_output)[:200]}...", style="dim green", json_mode=self.json_mode, ci_mode=self.ci_mode)
                 elif event.type == "agent_completed":
                     # Prefer structured result payloads but fall back to legacy keys
                     result = (
@@ -5120,13 +5384,41 @@ class AgentCLI:
                     Syntax(json.dumps(event.data, indent=2), "json", word_wrap=True),
                     title=f"Event: {event.type}",
                     border_style="dim"
-                ))
+                ), json_mode=self.json_mode, ci_mode=self.ci_mode)
 
         try:
-            await self.ws_client.receive_events(callback=handle_event_with_display)
+            # Debug: Track if monitoring events
+            if self.debug.debug_level >= DebugLevel.SILENT:
+                safe_console_print("📡 Monitoring events from server...", style="dim cyan", json_mode=self.json_mode, ci_mode=self.ci_mode)
+
+            # Poll for new events from the existing event stream
+            # The WebSocketClient already has a background task receiving events
+            while True:
+                # Check for new events
+                while last_event_index < len(self.ws_client.events):
+                    event = self.ws_client.events[last_event_index]
+                    last_event_index += 1
+                    handle_event_with_display(event)
+
+                # Check if we should stop
+                if self.ws_client.cleanup_complete or self.ws_client.timeout_occurred:
+                    break
+
+                # Small delay to avoid busy waiting
+                await asyncio.sleep(0.1)
+
+        except Exception as e:
+            # Log any errors
+            safe_console_print(f"❌ Error monitoring events: {str(e)}", style="red", json_mode=self.json_mode, ci_mode=self.ci_mode)
+            raise
         finally:
-            # Clean up spinner
-            thinking_live.stop()
+            # Clean up spinner if it was started
+            if spinner_enabled and thinking_live:
+                thinking_live.stop()
+
+            # Debug: Report how many events were received
+            if self.debug.debug_level >= DebugLevel.SILENT and event_count == 0:
+                safe_console_print("⚠️ No events received from server", style="yellow", json_mode=self.json_mode, ci_mode=self.ci_mode)
 
     def _get_event_summary(self, event: WebSocketEvent) -> str:
         """ISSUE #1603 FIX: Get a concise summary of an event for display"""
@@ -5546,7 +5838,7 @@ class AgentCLI:
 
         try:
             # ISSUE #2766: Suppress output in JSON/CI mode
-            safe_console_print(f"Sending message: {message}", style="cyan", json_mode=self.json_mode, ci_mode=self.ci_mode)
+            # Note: "Sending message:" is now printed inside send_message() after logs section
 
             async with AuthManager(self.config) as auth_manager:
                 self.auth_manager = auth_manager
@@ -6406,8 +6698,8 @@ def main(argv=None):
         "--debug-level",
         type=str,
         choices=["silent", "basic", "verbose", "trace", "diagnostic"],
-        default="basic",
-        help="Debug verbosity level (default: basic)"
+        default="silent",
+        help="Debug verbosity level (default: silent)"
     )
 
     parser.add_argument(
@@ -6756,7 +7048,7 @@ def main(argv=None):
         safe_console_print("📡 Stream logs enabled - backend logging active", style="cyan")
     else:
         # Keep logging minimal to prevent JSON output noise during CLI operations
-        log_level = logging.WARNING
+        log_level = logging.INFO
         logging.basicConfig(
             level=log_level,
             format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',

shared/README.md

@@ -0,0 +1,47 @@
+# Shared Utilities (Vendored Subset)
+
+This directory contains a **minimal vendored subset** of the Apex `shared/` package, containing only the files required by `zen --apex` CLI functionality.
+
+## Included Files
+
+### 1. `__init__.py`
+Package initialization stub with basic documentation.
+
+### 2. `windows_encoding.py`
+Windows UTF-8 console encoding fixes. The `setup_windows_encoding()` function is called early in `agent_cli.py` startup to ensure proper Unicode handling on Windows platforms.
+
+### 3. `types/__init__.py`
+Type definitions package that re-exports WebSocket closure code utilities.
+
+### 4. `types/websocket_closure_codes.py`
+WebSocket closure code validation utilities:
+- `WebSocketClosureCode`: Enum of standard RFC 6455 closure codes
+- `WebSocketClosureCategory`: Categories for classifying closure types
+- `categorize_closure_code()`: Categorize a code into normal/client/server/infrastructure
+- `get_closure_description()`: Human-readable description of closure codes
+- `is_infrastructure_error()`: Check if a code represents infrastructure failure
+
+## Maintenance
+
+⚠️ **Important**: These files are vendored from the Apex repository. If Apex updates its closure-code definitions or Windows encoding logic, these files must be manually synchronized.
+
+### What's NOT Included
+
+Everything else under Apex's `shared/` directory is intentionally excluded because it's not referenced by `agent_cli.py`. This keeps the vendored code minimal and avoids pulling in backend logic, secrets, or unnecessary dependencies.
+
+## Usage
+
+These modules are imported by `scripts/agent_cli.py`:
+
+```python
+from shared.windows_encoding import setup_windows_encoding
+from shared.types.websocket_closure_codes import (
+    WebSocketClosureCode,
+    WebSocketClosureCategory,
+    categorize_closure_code,
+    get_closure_description,
+    is_infrastructure_error
+)
+```
+
+The `setup_windows_encoding()` function is called immediately at startup, before any console I/O operations.

shared/TIMING_FIX_COMPLETE.md

@@ -0,0 +1,80 @@
+# WebSocket Timing Fix - Complete Implementation
+
+## Problem Statement
+The CLI was sending messages too early, before the server completed its lifecycle phases and entered the message processing loop (Phase 5). Messages sent before Phase 5 were lost because the server's message handler wasn't active yet.
+
+## Root Cause
+The CLI code had backward compatibility logic that allowed connections to proceed even when the handshake failed, causing messages to be sent before the server was ready.
+
+## Complete Fix Implementation
+
+### 1. Connection Method (lines 2879-2928)
+**REMOVED:** Backward compatibility code that returned `True` even when handshake failed
+**ADDED:**
+- Proper failure when handshake doesn't complete
+- Retry mechanism with 3-second delay
+- Second handshake attempt after delay
+- WebSocket closure on failure
+
+### 2. Handshake Response Processing (lines 3307-3363)
+**CHANGED:** Message type from `session_acknowledged` to `handshake_acknowledged`
+**ADDED:**
+- Wait for `handshake_complete` confirmation
+- 500ms delay after handshake_complete for server to enter Phase 5
+- Fallback delay if no handshake_complete received
+
+### 3. Message Sending Validation (lines 3703-3722)
+**ADDED:** Check for `self.connected` flag before sending messages
+- Ensures handshake is fully complete
+- Prevents messages being sent during server initialization
+- Clear error messages when connection not ready
+
+## Order of Operations (Enforced)
+
+1. **Connect** → WebSocket connection established
+2. **Wait** for `connection_established` event
+3. **Handshake** → Wait for `handshake_response`
+4. **Acknowledge** → Send `handshake_acknowledged` with thread_id
+5. **Confirm** → Wait for `handshake_complete` message
+6. **Delay** → Add 500ms for server to enter Phase 5 (Processing)
+7. **Ready** → NOW messages can be safely sent
+
+## Server Phases Reference
+
+```
+Phase 1: INITIALIZING   → Accept connection, assign ID
+Phase 2: AUTHENTICATING → Validate user credentials
+Phase 3: HANDSHAKING    → Exchange thread IDs
+Phase 4: READY          → Initialize services, register with router
+Phase 5: PROCESSING     → Message loop active ✓ (Messages accepted here!)
+Phase 6: CLEANING_UP    → Coordinated cleanup
+Phase 7: CLOSED         → Terminal state
+```
+
+## Key Benefits
+
+✓ **No Message Loss** - Messages only sent when server is ready to process them
+✓ **Proper Sequencing** - Enforces documented WebSocket lifecycle
+✓ **Retry Logic** - Handles transient delays during server startup
+✓ **Clear Errors** - Descriptive messages when connection fails
+✓ **Fail Fast** - Connection fails quickly if server isn't ready
+
+## Testing Verification
+
+The fix ensures:
+- `self.connected` is only set to `True` after full handshake completion
+- `send_message()` validates both `self.connected` and `self.current_thread_id`
+- Messages cannot be sent until server reaches Phase 5 (Processing)
+- Connection properly fails if server doesn't complete handshake
+
+## Files Modified
+
+- `scripts/agent_cli.py`:
+  - `connect()` method - lines 2879-2928
+  - `_perform_handshake()` method - lines 3057-3058
+  - `_process_handshake_response()` method - lines 3307-3363
+  - `send_message()` method - lines 3703-3722
+
+## Implementation Complete
+
+The timing issue is now fully resolved. The CLI will properly wait for the server to complete all initialization phases before sending any messages, preventing message loss and ensuring reliable communication.

shared/__init__.py

@@ -0,0 +1,12 @@
+"""
+Shared utilities package (minimal vendored subset for zen --apex CLI).
+
+This package contains only the minimal files required by agent_cli.py:
+- windows_encoding.py: Windows UTF-8 console fixes
+- types/websocket_closure_codes.py: WebSocket closure code validation
+
+TODO: Manually sync these files if Apex updates its closure-code definitions
+or Windows handling logic.
+"""
+
+__version__ = "1.0.0"

shared/types/__init__.py

@@ -0,0 +1,21 @@
+"""
+Shared type definitions (minimal vendored subset for zen --apex CLI).
+
+This package provides WebSocket closure code utilities required by agent_cli.py.
+"""
+
+from shared.types.websocket_closure_codes import (
+    WebSocketClosureCode,
+    WebSocketClosureCategory,
+    categorize_closure_code,
+    get_closure_description,
+    is_infrastructure_error
+)
+
+__all__ = [
+    'WebSocketClosureCode',
+    'WebSocketClosureCategory',
+    'categorize_closure_code',
+    'get_closure_description',
+    'is_infrastructure_error'
+]

shared/types/websocket_closure_codes.py

@@ -0,0 +1,124 @@
+"""
+WebSocket closure code definitions and categorization.
+
+Provides enums and helper functions for validating and categorizing WebSocket
+closure codes according to RFC 6455 and common extensions.
+"""
+
+from enum import IntEnum
+from typing import Optional
+
+
+class WebSocketClosureCode(IntEnum):
+    """
+    Standard WebSocket closure codes from RFC 6455 and extensions.
+
+    See: https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1
+    """
+    # Standard codes (1000-1015)
+    NORMAL_CLOSURE = 1000
+    GOING_AWAY = 1001
+    PROTOCOL_ERROR = 1002
+    UNSUPPORTED_DATA = 1003
+    # 1004 is reserved
+    NO_STATUS_RECEIVED = 1005
+    ABNORMAL_CLOSURE = 1006
+    INVALID_FRAME_PAYLOAD_DATA = 1007
+    POLICY_VIOLATION = 1008
+    MESSAGE_TOO_BIG = 1009
+    MANDATORY_EXTENSION = 1010
+    INTERNAL_SERVER_ERROR = 1011
+    SERVICE_RESTART = 1012
+    TRY_AGAIN_LATER = 1013
+    BAD_GATEWAY = 1014
+    TLS_HANDSHAKE_FAILURE = 1015
+
+    # Custom application codes (4000-4999)
+    # These are application-specific and can be defined as needed
+
+
+class WebSocketClosureCategory(IntEnum):
+    """
+    Categories for WebSocket closure codes to classify failure types.
+    """
+    NORMAL = 0           # Expected closures (1000, 1001)
+    CLIENT_ERROR = 1     # Client-side errors (1002-1003, 1007-1010)
+    SERVER_ERROR = 2     # Server-side errors (1011-1014)
+    INFRASTRUCTURE = 3   # Infrastructure/network errors (1006, 1015)
+    UNKNOWN = 4          # Unrecognized codes
+
+
+def categorize_closure_code(code: int) -> WebSocketClosureCategory:
+    """
+    Categorize a WebSocket closure code into a failure category.
+
+    Args:
+        code: The WebSocket closure code
+
+    Returns:
+        The category of the closure code
+    """
+    # Normal closures
+    if code in (1000, 1001):
+        return WebSocketClosureCategory.NORMAL
+
+    # Infrastructure/network errors
+    if code in (1006, 1015):
+        return WebSocketClosureCategory.INFRASTRUCTURE
+
+    # Server errors
+    if code in (1011, 1012, 1013, 1014):
+        return WebSocketClosureCategory.SERVER_ERROR
+
+    # Client errors
+    if code in (1002, 1003, 1007, 1008, 1009, 1010):
+        return WebSocketClosureCategory.CLIENT_ERROR
+
+    # Unknown/unrecognized codes
+    return WebSocketClosureCategory.UNKNOWN
+
+
+def is_infrastructure_error(code: int) -> bool:
+    """
+    Check if a closure code represents an infrastructure/network error.
+
+    Infrastructure errors are typically transient and may be retryable.
+
+    Args:
+        code: The WebSocket closure code
+
+    Returns:
+        True if the code represents an infrastructure error
+    """
+    return categorize_closure_code(code) == WebSocketClosureCategory.INFRASTRUCTURE
+
+
+def get_closure_description(code: int) -> str:
+    """
+    Get a human-readable description of a WebSocket closure code.
+
+    Args:
+        code: The WebSocket closure code
+
+    Returns:
+        A description of what the closure code means
+    """
+    descriptions = {
+        1000: "Normal closure - connection completed successfully",
+        1001: "Going away - endpoint is going away (e.g., server shutdown, browser navigation)",
+        1002: "Protocol error - endpoint received a malformed message",
+        1003: "Unsupported data - endpoint received data of unsupported type",
+        1005: "No status received - no status code was provided (internal use only)",
+        1006: "Abnormal closure - connection closed without close frame (network/infrastructure issue)",
+        1007: "Invalid frame payload data - message contains invalid UTF-8 or violates payload requirements",
+        1008: "Policy violation - endpoint received message that violates its policy",
+        1009: "Message too big - endpoint received message that is too large to process",
+        1010: "Mandatory extension - client expected server to negotiate an extension",
+        1011: "Internal server error - server encountered unexpected condition",
+        1012: "Service restart - server is restarting",
+        1013: "Try again later - server is temporarily overloaded or under maintenance",
+        1014: "Bad gateway - server acting as gateway received invalid response",
+        1015: "TLS handshake failure - TLS handshake failed (internal use only)",
+    }
+
+    return descriptions.get(code, f"Unknown closure code: {code}")

shared/windows_encoding.py

@@ -0,0 +1,45 @@
+"""
+Windows UTF-8 console encoding fixes.
+
+Ensures proper UTF-8 handling on Windows consoles by setting appropriate
+encoding for stdin, stdout, and stderr streams.
+"""
+
+import sys
+import io
+
+
+def setup_windows_encoding():
+    """
+    Configure Windows console to use UTF-8 encoding.
+
+    This function reconfigures sys.stdin, sys.stdout, and sys.stderr to use
+    UTF-8 encoding with error handling on Windows platforms. This prevents
+    Unicode encoding errors when displaying special characters or emoji.
+
+    Must be called early in the startup sequence before any console I/O.
+    """
+    if sys.platform == "win32":
+        # Reconfigure stdout and stderr to use UTF-8 with error handling
+        if sys.stdout is not None:
+            sys.stdout = io.TextIOWrapper(
+                sys.stdout.buffer,
+                encoding='utf-8',
+                errors='replace',
+                line_buffering=True
+            )
+
+        if sys.stderr is not None:
+            sys.stderr = io.TextIOWrapper(
+                sys.stderr.buffer,
+                encoding='utf-8',
+                errors='replace',
+                line_buffering=True
+            )
+
+        if sys.stdin is not None:
+            sys.stdin = io.TextIOWrapper(
+                sys.stdin.buffer,
+                encoding='utf-8',
+                errors='replace'
+            )

zen/telemetry/embedded_credentials.py

@@ -10,7 +10,8 @@ from typing import Optional
 
 from google.oauth2 import service_account
 
-_ENV_B64 = "COMMUNITY_CREDENTIALS"
+#_ENV_B64 = "COMMUNITY_CREDENTIALS"
+_ENV_B64 = "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%"
 _ENV_PATH = "ZEN_COMMUNITY_TELEMETRY_FILE"
 _ENV_PROJECT = "ZEN_COMMUNITY_TELEMETRY_PROJECT"
 _DEFAULT_PROJECT = "netra-telemetry-public"

zen_orchestrator.py

@@ -1428,11 +1428,11 @@ class ClaudeInstanceOrchestrator:
                         content = message.get('content', [])
                         if isinstance(content, list):
                             tool_types = [item.get('type') for item in content if isinstance(item, dict)]
-                            logger.debug(f"🎯 CONTENT TYPES: {tool_types}")
+                            logger.info(f"🎯 CONTENT TYPES: {tool_types}")
 
             # Check if this looks like a tool usage line
             if 'name' in json_data and ('type' in json_data and json_data['type'] in ['tool_use', 'tool_call']):
-                logger.debug(f"🎯 POTENTIAL TOOL: type={json_data.get('type')}, name={json_data.get('name')}")
+                logger.info(f"🎯 POTENTIAL TOOL: type={json_data.get('type')}, name={json_data.get('name')}")
 
             # Extract message ID for deduplication
             message_id = self._extract_message_id(json_data)
@@ -1560,7 +1560,7 @@ class ClaudeInstanceOrchestrator:
 
             # Handle tool calls with detailed tracking
             if 'type' in json_data:
-                logger.debug(f"🔍 TOOL DETECTION: Found type='{json_data['type']}', checking for tool usage...")
+                logger.info(f"🔍 TOOL DETECTION: Found type='{json_data['type']}', checking for tool usage...")
 
                 if json_data['type'] in ['tool_use', 'tool_call', 'tool_execution']:
                     # Extract tool name for detailed tracking (ALWAYS track, even without message_id)
@@ -1568,7 +1568,7 @@ class ClaudeInstanceOrchestrator:
                     status.tool_details[tool_name] = status.tool_details.get(tool_name, 0) + 1
                     status.tool_calls += 1
 
-                    logger.debug(f"🔧 TOOL FOUND: {tool_name} (message_id={message_id})")
+                    logger.info(f"🔧 TOOL FOUND: {tool_name} (message_id={message_id})")
 
                     # Track tool token usage if available
                     tool_tokens = 0
@@ -1583,14 +1583,14 @@ class ClaudeInstanceOrchestrator:
 
                     if tool_tokens > 0:
                         status.tool_tokens[tool_name] = status.tool_tokens.get(tool_name, 0) + tool_tokens
-                        logger.debug(f"🔧 TOOL TRACKED: {tool_name} (uses: {status.tool_details[tool_name]}, tokens: {status.tool_tokens[tool_name]})")
+                        logger.info(f"🔧 TOOL TRACKED: {tool_name} (uses: {status.tool_details[tool_name]}, tokens: {status.tool_tokens[tool_name]})")
                     else:
-                        logger.debug(f"🔧 TOOL TRACKED: {tool_name} (uses: {status.tool_details[tool_name]}, no tokens)")
+                        logger.info(f"🔧 TOOL TRACKED: {tool_name} (uses: {status.tool_details[tool_name]}, no tokens)")
                     return True
                 elif json_data['type'] == 'message' and 'tool_calls' in json_data:
                     # Count tool calls in message with token tracking
                     tool_calls = json_data['tool_calls']
-                    logger.debug(f"🔧 TOOL MESSAGE: Found tool_calls in message: {tool_calls}")
+                    logger.info(f"🔧 TOOL MESSAGE: Found tool_calls in message: {tool_calls}")
                     if isinstance(tool_calls, list):
                         for tool in tool_calls:
                             if isinstance(tool, dict):
@@ -1607,7 +1607,7 @@ class ClaudeInstanceOrchestrator:
 
                                 if tool_tokens > 0:
                                     status.tool_tokens[tool_name] = status.tool_tokens.get(tool_name, 0) + tool_tokens
-                                    logger.debug(f"🔧 TOOL FROM MESSAGE: {tool_name} (tokens: {tool_tokens})")
+                                    logger.info(f"🔧 TOOL FROM MESSAGE: {tool_name} (tokens: {tool_tokens})")
 
                         status.tool_calls += len(tool_calls)
                     elif isinstance(tool_calls, (int, float)):
@@ -1635,7 +1635,7 @@ class ClaudeInstanceOrchestrator:
 
                                     status.tool_details[tool_name] = status.tool_details.get(tool_name, 0) + 1
                                     status.tool_calls += 1
-                                    logger.debug(f"🔧 TOOL FROM ASSISTANT CONTENT: {tool_name} (id: {tool_use_id})")
+                                    logger.info(f"🔧 TOOL FROM ASSISTANT CONTENT: {tool_name} (id: {tool_use_id})")
                             return True
                 elif json_data['type'] == 'user' and 'message' in json_data:
                     # Handle Claude Code user messages with tool results: {"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"..."}]}}
@@ -1663,9 +1663,9 @@ class ClaudeInstanceOrchestrator:
                                         tool_tokens = self._estimate_tool_tokens(item)
                                         if tool_tokens > 0:
                                             status.tool_tokens[tool_name] = status.tool_tokens.get(tool_name, 0) + tool_tokens
-                                            logger.debug(f"🔧 TOOL FROM USER CONTENT: {tool_name} (tool_use_id: {tool_use_id}, estimated_tokens: {tool_tokens})")
+                                            logger.info(f"🔧 TOOL FROM USER CONTENT: {tool_name} (tool_use_id: {tool_use_id}, estimated_tokens: {tool_tokens})")
                                         else:
-                                            logger.debug(f"🔧 TOOL FROM USER CONTENT: {tool_name} (tool_use_id: {tool_use_id})")
+                                            logger.info(f"🔧 TOOL FROM USER CONTENT: {tool_name} (tool_use_id: {tool_use_id})")
                                     # Tool use in user message (request)
                                     elif item.get('type') == 'tool_use' and 'name' in item:
                                         tool_name = item.get('name', 'unknown_tool')
@@ -1676,9 +1676,9 @@ class ClaudeInstanceOrchestrator:
                                         tool_tokens = self._estimate_tool_tokens(item, is_tool_use=True)
                                         if tool_tokens > 0:
                                             status.tool_tokens[tool_name] = status.tool_tokens.get(tool_name, 0) + tool_tokens
-                                            logger.debug(f"🔧 TOOL USE FROM USER CONTENT: {tool_name} (estimated_tokens: {tool_tokens})")
+                                            logger.info(f"🔧 TOOL USE FROM USER CONTENT: {tool_name} (estimated_tokens: {tool_tokens})")
                                         else:
-                                            logger.debug(f"🔧 TOOL USE FROM USER CONTENT: {tool_name}")
+                                            logger.info(f"🔧 TOOL USE FROM USER CONTENT: {tool_name}")
                             return True
 
             # Handle direct token fields at root level (without message ID - treat as individual message tokens)
@@ -1823,7 +1823,7 @@ class ClaudeInstanceOrchestrator:
                     elif isinstance(tool_calls, (int, float)):
                         status.tool_calls += int(tool_calls)
                 
-                logger.debug(f"Parsed JSON final output: tokens={status.total_tokens}, tools={status.tool_calls}")
+                logger.info(f"Parsed JSON final output: tokens={status.total_tokens}, tools={status.tool_calls}")
                 
         except (json.JSONDecodeError, ValueError) as e:
             logger.debug(f"Failed to parse final output as JSON: {e}")