@matt82198/aesop 0.1.0 → 0.3.1

package/ui/handler.py

@@ -12,8 +12,15 @@ from pathlib import Path
 import config
 import cost
 import csrf
+import quality_scorecard
 import sse
 import wave_prs
+import wave_telemetry
+import wave_failure
+import wave_dispatch
+import wave_gantt
+import wave_audit_tail
+import wave_reasoning_tail
 import api
 import api.tracker
 import api.submit
@@ -75,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.
 
@@ -197,6 +230,20 @@ class DashboardHandler(http.server.BaseHTTPRequestHandler):
             self.serve_api_cost()
         elif self.path == "/api/wave/prs":
             self.serve_api_wave_prs()
+        elif self.path == "/api/wave/telemetry":
+            self.serve_api_wave_telemetry()
+        elif self.path == "/api/wave/dispatch":
+            self.serve_api_wave_dispatch()
+        elif self.path == "/api/wave/gantt":
+            self.serve_api_wave_gantt()
+        elif self.path == "/api/wave/audit-tail":
+            self.serve_api_wave_audit_tail()
+        elif self.path == "/api/wave/reasoning-tail":
+            self.serve_api_wave_reasoning_tail()
+        elif self.path == "/api/wave/quality-scorecards":
+            self.serve_api_wave_quality_scorecards()
+        elif self.path.startswith("/api/wave/failure"):
+            self.serve_api_wave_failure()
         elif self.path == "/api/backlog":
             self.serve_backlog()
         elif self.path == "/api/agents":
@@ -314,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):
@@ -355,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).
@@ -400,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.
@@ -421,28 +484,244 @@ 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)
+            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.
+
+        Read-only; reads state at call time (no caching). Returns wave phase info,
+        current cost metrics, and top blocker from AUDIT-BACKLOG.md.
+        """
+        try:
+            payload = wave_telemetry.get_wave_telemetry()
+            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({"error": "Internal server error"}).encode('utf-8'))
+            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)
+            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.
+
+        Read-only; reads at call time (no caching). Returns per-agent phase,
+        last-activity age, and token burn estimates. Degrades to {available:false}
+        when no active workflow.
+        """
+        try:
+            payload = wave_dispatch.get_wave_dispatch()
+            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(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)
+            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.
+
+        Read-only; reads at call time (no caching). Returns per-agent rows with
+        phase timing spans suitable for Gantt visualization. Degrades to
+        {available:false} when no active workflow.
+        """
+        try:
+            payload = wave_gantt.get_wave_gantt()
+            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(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)
+            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.
+
+        Read-only; reads at call time (no caching). Returns recent audit backlog
+        items and ledger verdicts as a compact tail. Shows latest findings from
+        adversarial reviews and verify verdicts.
+        """
+        try:
+            payload = wave_audit_tail.get_wave_audit_tail()
+            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(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)
+            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.
+
+        Read-only; reads at call time (no caching). Returns latest transcript activity
+        summary for each live agent (redacted). Shows thinking/tool-call sequences
+        in a compact format suitable for Activity view transparency.
+        """
+        try:
+            payload = wave_reasoning_tail.get_wave_reasoning_tail()
+            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(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)
+            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.
+
+        Read-only; reads at call time (no caching). Returns per-specialty quality:
+        success rate (green/total) and retry/repair frequency from ledger.
+        Includes top rankings by success and retry frequency.
+        """
+        try:
+            payload = quality_scorecard.get_quality_scorecard()
+            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(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)
+            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.
+
+        Read-only; shells `gh run view --json jobs` / `gh api .../logs` (short timeout,
+        cached a few seconds). Degrades to {available:false, error:...} when gh is
+        missing or un-authenticated — never a 500 for those.
+
+        Query params:
+          pr: PR number (required)
+        """
+        try:
+            # Parse query string for pr parameter
+            query = urllib.parse.urlparse(self.path).query
+            params = urllib.parse.parse_qs(query)
+            pr_str = params.get('pr', [None])[0]
+
+            if not pr_str or not pr_str.isdigit():
+                self.send_response(400)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "pr parameter required and must be a number"}).encode('utf-8'))
+                return
+
+            pr_number = int(pr_str)
+            payload = wave_failure.get_wave_failure(pr_number)
+            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(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)
+            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."""
@@ -460,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)."""
@@ -485,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)."""
@@ -534,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):
@@ -552,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."""
@@ -568,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>"""
@@ -612,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):
@@ -655,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):
@@ -700,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:
@@ -711,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:
@@ -742,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:
@@ -799,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):