@matt82198/aesop 0.2.0 → 0.3.2

package/ui/collectors.py

@@ -315,6 +315,87 @@ def get_alerts():
         print(f"[collectors] Failed to read alerts: {e}", file=sys.stderr)
     return alerts
 
+def get_agent_lifecycle_events():
+    """Collect agent lifecycle events from transcript analysis.
+
+    Scans agent-*.jsonl files to infer agent state transitions.
+    Returns structured events for Activity view rendering.
+
+    Event format (list of dicts):
+    [
+        {
+            "agent_id": "12345",
+            "state": "dispatch" | "working" | "done" | "stalled",
+            "last_activity": ISO 8601 timestamp (transcript mtime),
+            "age_sec": seconds since last activity,
+            "transitions": [
+                {"state": "dispatch", "at": "2026-07-22T...Z"},
+                {"state": "working", "at": "2026-07-22T...Z"},
+            ]
+        }
+    ]
+
+    If transcripts unavailable or no agents found, returns empty list.
+    """
+    events = []
+    try:
+        # Use wave_dispatch.py's existing logic for consistency
+        import wave_dispatch as wd
+
+        dispatch_data = wd.get_wave_dispatch(force=False)
+        if not dispatch_data.get("available"):
+            return events
+
+        # Convert phase and timing data to lifecycle event structure
+        agents_data = dispatch_data.get("agents", [])
+        now_ts = datetime.now(timezone.utc)
+
+        for agent in agents_data:
+            agent_id = agent.get("id")
+            phase = agent.get("phase")
+            age_sec = agent.get("last_activity_age_sec", 0)
+
+            if not agent_id:
+                continue
+
+            # Map phase to state
+            phase_to_state = {
+                "dispatch": "dispatch",
+                "thinking": "working",
+                "tool-use": "working",
+                "stall": "stalled",
+                "done": "done",
+                "unknown": "working",
+            }
+            state = phase_to_state.get(phase, "working")
+
+            # Estimate activity timestamp from age
+            if age_sec >= 0:
+                activity_ts = now_ts.timestamp() - age_sec
+                activity_dt = datetime.fromtimestamp(activity_ts, timezone.utc)
+                last_activity = activity_dt.isoformat(timespec='seconds').replace('+00:00', 'Z')
+            else:
+                last_activity = now_ts.isoformat(timespec='seconds').replace('+00:00', 'Z')
+
+            event = {
+                "agent_id": agent_id,
+                "state": state,
+                "last_activity": last_activity,
+                "age_sec": age_sec,
+                "transitions": [
+                    {
+                        "state": state,
+                        "at": last_activity,
+                    }
+                ],
+            }
+            events.append(event)
+
+    except Exception as e:
+        print(f"[collectors] Failed to collect agent lifecycle events: {e}", file=sys.stderr)
+
+    return events
+
 def load_tracker():
     """Load tracker.json, return empty tracker if missing or corrupt.
 

package/ui/handler.py

@@ -82,6 +82,32 @@ _ASSET_MIME = {
 }
 
 
+def _is_client_disconnect_error(exc):
+    """True if exception indicates a normal client disconnect (not an error).
+
+    When clients close connections mid-stream (tab closed, network drop, etc.),
+    we get BrokenPipeError, ConnectionAbortedError, or ConnectionResetError.
+    On Windows, rare plain OSError with winerror 10053/10054 may also indicate
+    a disconnect. These are normal lifecycle events, not bugs, and should not
+    be logged as errors.
+
+    Args:
+        exc: The exception to check
+
+    Returns:
+        bool: True if this is a normal disconnect, False if it's an unexpected error
+    """
+    if isinstance(exc, (BrokenPipeError, ConnectionAbortedError,
+                       ConnectionResetError)):
+        return True
+    if isinstance(exc, OSError):
+        # Windows disconnect errors: 10053 (WSAECONNABORTED), 10054 (WSAECONNRESET)
+        winerror = getattr(exc, 'winerror', None)
+        if winerror in (10053, 10054):
+            return True
+    return False
+
+
 def _is_local_origin(origin):
     """True if an Origin header value is on the local allowlist.
 
@@ -335,10 +361,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.send_header("Cache-Control", "public, max-age=31536000, immutable")
             self.end_headers()
             self.wfile.write(content)
-        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError, OSError):
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
             pass  # client went away mid-response — normal, not an error
+        except OSError as e:
+            if not _is_client_disconnect_error(e):
+                print(f"[serve_asset] Uncaught OSError: {e}", file=sys.stderr)
+                self.send_error(500)
+            # else: silently pass for disconnect errors
         except Exception as e:
-            print(f"[serve_asset] Uncaught exception: {e}", file=sys.stderr)
+            if not _is_client_disconnect_error(e):
+                print(f"[serve_asset] Uncaught exception: {e}", file=sys.stderr)
             self.send_error(500)
 
     def serve_api_state(self):
@@ -376,11 +408,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(state, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_state] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_session(self):
         """GET /api/session — the CSRF token for same-origin JS (plan D3.3).
@@ -421,11 +458,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(summary, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_cost] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_prs(self):
         """GET /api/wave/prs — open PRs + PR-less feat/* branches for the PR board.
@@ -442,11 +484,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_prs] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_telemetry(self):
         """GET /api/wave/telemetry — current wave phase, cost metrics, and top blocker.
@@ -462,11 +509,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_telemetry] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_dispatch(self):
         """GET /api/wave/dispatch — live per-agent phase and activity visibility.
@@ -483,11 +535,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_dispatch] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_gantt(self):
         """GET /api/wave/gantt — Gantt timeline data for agents in current wave.
@@ -504,11 +561,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_gantt] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_audit_tail(self):
         """GET /api/wave/audit-tail — latest audit/verification outcomes.
@@ -525,11 +587,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_audit_tail] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_reasoning_tail(self):
         """GET /api/wave/reasoning-tail — per-agent live reasoning/transcript summary.
@@ -546,11 +613,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_reasoning_tail] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_quality_scorecards(self):
         """GET /api/wave/quality-scorecards — per-agent-specialty quality metrics.
@@ -567,11 +639,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_quality_scorecards] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_api_wave_failure(self):
         """GET /api/wave/failure?pr=N — CI job logs and failure details for a PR.
@@ -604,28 +681,47 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(payload, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_api_wave_failure] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_data(self):
         """Serve dashboard data as JSON."""
-        data = {
-            "watchdog": get_heartbeat_status(),
-            "monitor": get_monitor_heartbeat_status(),
-            "agents": get_fleet_agents(),
-            "repos": get_repos_status(),
-            "events": get_recent_events(),
-            "alerts": get_alerts(),
-            "messages": get_main_thread_messages(),
-        }
-        self.send_response(200)
-        self.send_header("Content-Type", "application/json; charset=utf-8")
-        self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
-        self.end_headers()
-        self.wfile.write(json.dumps(data, default=str).encode('utf-8'))
+        try:
+            data = {
+                "watchdog": get_heartbeat_status(),
+                "monitor": get_monitor_heartbeat_status(),
+                "agents": get_fleet_agents(),
+                "repos": get_repos_status(),
+                "events": get_recent_events(),
+                "alerts": get_alerts(),
+                "messages": get_main_thread_messages(),
+            }
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json; charset=utf-8")
+            self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
+            self.end_headers()
+            self.wfile.write(json.dumps(data, default=str).encode('utf-8'))
+        except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
+            print(f"[serve_data] Uncaught exception: {e}", file=sys.stderr)
+            try:
+                # Best-effort 500 response
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                # Sending to a dead client must not cascade
+                pass
 
     def serve_tracker(self):
         """Serve tracker items as JSON via GET /api/tracker."""
@@ -643,11 +739,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(body, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_tracker] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def handle_tracker_create(self):
         """Handle POST /api/tracker (create item)."""
@@ -668,12 +769,19 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.send_header("Content-Type", "application/json; charset=utf-8")
             self.end_headers()
             self.wfile.write(json.dumps(result, default=str).encode('utf-8'))
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
+            pass  # Client disconnected — normal lifecycle, not an error.
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[handle_tracker_create] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def handle_tracker_mutate(self):
         """Handle POST /api/tracker/<id> (update or delete)."""
@@ -717,12 +825,19 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
                 self.send_header("Content-Type", "application/json; charset=utf-8")
                 self.end_headers()
                 self.wfile.write(json.dumps(result, default=str).encode('utf-8'))
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
+            pass  # Client disconnected — normal lifecycle, not an error.
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[handle_tracker_mutate] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
 
     def serve_backlog(self):
@@ -735,11 +850,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(data, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_backlog] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_agents(self):
         """Serve rich agent list with metadata via GET /api/agents."""
@@ -751,11 +871,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps(agents, default=str).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[serve_agents] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
     def serve_agent(self):
         """Serve agent dispatch prompt and metadata via GET /agent?id=<agent_id>"""
@@ -795,7 +920,8 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.send_response(500)
             self.send_header("Content-Type", "application/json; charset=utf-8")
             self.end_headers()
-            print(f"[serve_agent] Uncaught exception: {e}", file=sys.stderr)
+            if not _is_client_disconnect_error(e):
+                print(f"[serve_agent] Uncaught exception: {e}", file=sys.stderr)
             self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
 
     def serve_api_agent(self):
@@ -838,7 +964,8 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.send_response(500)
             self.send_header("Content-Type", "application/json; charset=utf-8")
             self.end_headers()
-            print(f"[serve_api_agent] Uncaught exception: {e}", file=sys.stderr)
+            if not _is_client_disconnect_error(e):
+                print(f"[serve_api_agent] Uncaught exception: {e}", file=sys.stderr)
             self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
 
     def _write_sse_event(self, event_name, payload):
@@ -883,8 +1010,12 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
                 self.send_header("Retry-After", "30")
                 self.end_headers()
                 self.wfile.write(b"Service overloaded: too many concurrent clients\n")
-            except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError, OSError):
+            except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
                 pass
+            except OSError as e:
+                if not _is_client_disconnect_error(e):
+                    print(f"[serve_events cap-exceeded] Uncaught OSError: {e}", file=sys.stderr)
+                # else: silently pass for disconnect errors
             return
 
         try:
@@ -894,7 +1025,12 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.send_header("Connection", "keep-alive")
             self.send_header("X-Accel-Buffering", "no")
             self.end_headers()
-        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError, OSError):
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
+            unregister_sse_client(q)
+            return
+        except OSError as e:
+            if not _is_client_disconnect_error(e):
+                print(f"[serve_events headers] Uncaught OSError: {e}", file=sys.stderr)
             unregister_sse_client(q)
             return
         try:
@@ -925,9 +1061,13 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
                 except queue.Empty:
                     self.wfile.write(b": keepalive\n\n")
                     self.wfile.flush()
-        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError, OSError):
+        except (BrokenPipeError, ConnectionAbortedError, ConnectionResetError):
             # Client disconnected (tab closed, network drop) — normal, not an error.
             pass
+        except OSError as e:
+            if not _is_client_disconnect_error(e):
+                print(f"[serve_events stream] Uncaught OSError: {e}", file=sys.stderr)
+            # else: silently pass for disconnect errors
         except Exception:
             pass
         finally:
@@ -982,11 +1122,16 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(json.dumps({"ok": True}).encode('utf-8'))
         except Exception as e:
+            if _is_client_disconnect_error(e):
+                return  # client gone: nothing to send or log
             print(f"[handle_submit] Uncaught exception: {e}", file=sys.stderr)
-            self.send_response(500)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.end_headers()
-            self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            try:
+                self.send_response(500)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "Internal server error"}).encode('utf-8'))
+            except Exception:
+                pass  # best-effort error response; client may be gone
 
 
 class QuietThreadingHTTPServer(http.server.ThreadingHTTPServer):

package/ui/sse.py

@@ -165,14 +165,14 @@ def collector_loop(stop_event):
             # Wave-19: Gate data section on mtimes+sizes to avoid expensive file reads every tick.
             # Only regenerate the snapshot if one of the underlying log files changed.
             try:
-                backup_log_stat = config.BACKUP_LOG.stat() if config.BACKUP_LOG.exists() else None
+                backup_log_stat = config.BACKUP_LOG.stat() if config.BACKUP_LOG and config.BACKUP_LOG.exists() else None
                 backup_log_mtime = backup_log_stat.st_mtime if backup_log_stat else None
                 backup_log_size = backup_log_stat.st_size if backup_log_stat else None
             except OSError:
                 backup_log_mtime = None
                 backup_log_size = None
             try:
-                alerts_log_stat = config.ALERTS_LOG.stat() if config.ALERTS_LOG.exists() else None
+                alerts_log_stat = config.ALERTS_LOG.stat() if config.ALERTS_LOG and config.ALERTS_LOG.exists() else None
                 alerts_log_mtime = alerts_log_stat.st_mtime if alerts_log_stat else None
                 alerts_log_size = alerts_log_stat.st_size if alerts_log_stat else None
             except OSError:
@@ -236,7 +236,7 @@ def collector_loop(stop_event):
 
             # Emit cost section (mtime+size-gated on the outcomes ledger)
             try:
-                cost_stat = config.LEDGER_FILE.stat() if config.LEDGER_FILE.exists() else None
+                cost_stat = config.LEDGER_FILE.stat() if config.LEDGER_FILE and config.LEDGER_FILE.exists() else None
                 cost_mtime = cost_stat.st_mtime if cost_stat else None
                 cost_size = cost_stat.st_size if cost_stat else None
             except OSError: