shipwright-cli 2.3.1 → 3.0.0

package/config/policy.schema.json

@@ -1,13 +1,174 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Shipwright Policy",
-  "description": "Central policy for Shipwright — timeouts, limits, thresholds. Validated by CI platform-health workflow.",
+  "description": "Central policy for Shipwright — timeouts, limits, thresholds, risk tiers, merge gates. Single source of truth for the Code Factory pattern.",
   "type": "object",
   "required": ["version"],
   "properties": {
     "$schema": { "type": "string" },
     "description": { "type": "string" },
     "version": { "type": "string" },
+    "riskTierRules": {
+      "type": "object",
+      "description": "Path-based risk classification. Tiers: critical, high, medium, low. Glob patterns matched against changed files.",
+      "properties": {
+        "critical": { "type": "array", "items": { "type": "string" } },
+        "high": { "type": "array", "items": { "type": "string" } },
+        "medium": { "type": "array", "items": { "type": "string" } },
+        "low": { "type": "array", "items": { "type": "string" } }
+      },
+      "additionalProperties": false
+    },
+    "mergePolicy": {
+      "type": "object",
+      "description": "Required checks and evidence by risk tier before merge is allowed.",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "requiredChecks": { "type": "array", "items": { "type": "string" } },
+          "requiredReviewers": { "type": "integer", "minimum": 0 },
+          "requiredEvidence": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["browser", "api", "database", "cli", "webhook", "custom"]
+            },
+            "description": "Evidence types required before merge for this tier"
+          },
+          "requireDocsDriftCheck": { "type": "boolean" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "docsDriftRules": {
+      "type": "object",
+      "description": "Detect when control-plane files change without corresponding doc updates.",
+      "properties": {
+        "trackedPairs": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "source": { "type": "string" },
+              "docs": { "type": "array", "items": { "type": "string" } }
+            },
+            "required": ["source", "docs"]
+          }
+        },
+        "failOnDrift": { "type": "boolean" },
+        "warnOnDrift": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "evidence": {
+      "type": "object",
+      "description": "Evidence framework — machine-verifiable proof for browser, API, database, CLI, and webhook changes. Each collector defines a type-specific verification strategy.",
+      "properties": {
+        "artifactMaxAgeMinutes": { "type": "integer", "minimum": 1 },
+        "requireFreshArtifacts": { "type": "boolean" },
+        "collectors": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "description": "Unique name for this evidence collector"
+              },
+              "type": {
+                "type": "string",
+                "enum": [
+                  "browser",
+                  "api",
+                  "database",
+                  "cli",
+                  "webhook",
+                  "custom"
+                ],
+                "description": "Evidence type: browser (HTTP page load), api (REST/GraphQL endpoint), database (schema/migration check), cli (command execution), webhook (callback verification), custom (user-defined script)"
+              },
+              "entrypoint": {
+                "type": "string",
+                "description": "URL path for browser evidence"
+              },
+              "baseUrl": {
+                "type": "string",
+                "description": "Base URL for browser/api evidence"
+              },
+              "url": {
+                "type": "string",
+                "description": "Full URL for api evidence"
+              },
+              "method": {
+                "type": "string",
+                "enum": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"],
+                "description": "HTTP method for api evidence"
+              },
+              "command": {
+                "type": "string",
+                "description": "Shell command for cli/database evidence"
+              },
+              "expectedStatus": {
+                "type": "integer",
+                "description": "Expected HTTP status code for api evidence"
+              },
+              "expectedExitCode": {
+                "type": "integer",
+                "description": "Expected exit code for cli/database evidence"
+              },
+              "headers": {
+                "type": "object",
+                "additionalProperties": { "type": "string" },
+                "description": "HTTP headers for api evidence"
+              },
+              "body": {
+                "type": "string",
+                "description": "Request body for api evidence"
+              },
+              "assertions": {
+                "type": "array",
+                "items": { "type": "string" },
+                "description": "Named assertions to validate"
+              },
+              "timeout": {
+                "type": "integer",
+                "minimum": 1,
+                "description": "Timeout in seconds for this collector"
+              }
+            },
+            "required": ["name", "type", "assertions"]
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "harnessGapPolicy": {
+      "type": "object",
+      "description": "Incident-to-harness loop: every regression must produce a test case within SLA.",
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "p0SlaHours": { "type": "integer", "minimum": 1 },
+        "p1SlaHours": { "type": "integer", "minimum": 1 },
+        "p2SlaHours": { "type": "integer", "minimum": 1 },
+        "autoCreateGapIssue": { "type": "boolean" },
+        "requireTestCaseBeforeClose": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
+    "codeReviewAgent": {
+      "type": "object",
+      "description": "Code review agent configuration — provider-agnostic settings for rerun, resolve, and remediation.",
+      "properties": {
+        "provider": { "type": "string" },
+        "rerunMarker": { "type": "string" },
+        "timeoutMinutes": { "type": "integer", "minimum": 1 },
+        "treatVulnerabilityLanguageAsActionable": { "type": "boolean" },
+        "treatWeakConfidenceAsActionable": { "type": "boolean" },
+        "autoResolveBotsOnlyThreads": { "type": "boolean" },
+        "neverAutoResolveHumanThreads": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    },
     "daemon": {
       "type": "object",
       "properties": {

package/dashboard/coverage/coverage-summary.json

@@ -0,0 +1,14 @@
+{"total": {"lines":{"total":602,"covered":593,"skipped":0,"pct":98.5},"statements":{"total":671,"covered":657,"skipped":0,"pct":97.91},"functions":{"total":142,"covered":139,"skipped":0,"pct":97.88},"branches":{"total":311,"covered":285,"skipped":0,"pct":91.63},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":100}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/components/charts/bar.ts": {"lines":{"total":30,"covered":30,"skipped":0,"pct":100},"functions":{"total":1,"covered":1,"skipped":0,"pct":100},"statements":{"total":34,"covered":34,"skipped":0,"pct":100},"branches":{"total":28,"covered":27,"skipped":0,"pct":96.42}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/components/charts/donut.ts": {"lines":{"total":13,"covered":13,"skipped":0,"pct":100},"functions":{"total":1,"covered":1,"skipped":0,"pct":100},"statements":{"total":13,"covered":13,"skipped":0,"pct":100},"branches":{"total":0,"covered":0,"skipped":0,"pct":100}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/components/charts/pipeline-rail.ts": {"lines":{"total":58,"covered":58,"skipped":0,"pct":100},"functions":{"total":2,"covered":2,"skipped":0,"pct":100},"statements":{"total":62,"covered":62,"skipped":0,"pct":100},"branches":{"total":34,"covered":31,"skipped":0,"pct":91.17}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/components/charts/sparkline.ts": {"lines":{"total":44,"covered":44,"skipped":0,"pct":100},"functions":{"total":2,"covered":2,"skipped":0,"pct":100},"statements":{"total":52,"covered":52,"skipped":0,"pct":100},"branches":{"total":36,"covered":34,"skipped":0,"pct":94.44}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/core/api.ts": {"lines":{"total":142,"covered":141,"skipped":0,"pct":99.29},"functions":{"total":74,"covered":73,"skipped":0,"pct":98.64},"statements":{"total":151,"covered":149,"skipped":0,"pct":98.67},"branches":{"total":31,"covered":28,"skipped":0,"pct":90.32}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/core/helpers.ts": {"lines":{"total":65,"covered":65,"skipped":0,"pct":100},"functions":{"total":14,"covered":14,"skipped":0,"pct":100},"statements":{"total":87,"covered":87,"skipped":0,"pct":100},"branches":{"total":65,"covered":65,"skipped":0,"pct":100}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/core/router.ts": {"lines":{"total":94,"covered":94,"skipped":0,"pct":100},"functions":{"total":14,"covered":14,"skipped":0,"pct":100},"statements":{"total":100,"covered":99,"skipped":0,"pct":99},"branches":{"total":52,"covered":49,"skipped":0,"pct":94.23}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/core/sse.ts": {"lines":{"total":14,"covered":14,"skipped":0,"pct":100},"functions":{"total":6,"covered":6,"skipped":0,"pct":100},"statements":{"total":15,"covered":15,"skipped":0,"pct":100},"branches":{"total":4,"covered":3,"skipped":0,"pct":75}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/core/state.ts": {"lines":{"total":38,"covered":38,"skipped":0,"pct":100},"functions":{"total":13,"covered":13,"skipped":0,"pct":100},"statements":{"total":44,"covered":44,"skipped":0,"pct":100},"branches":{"total":14,"covered":14,"skipped":0,"pct":100}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/core/ws.ts": {"lines":{"total":85,"covered":77,"skipped":0,"pct":90.58},"functions":{"total":14,"covered":12,"skipped":0,"pct":85.71},"statements":{"total":93,"covered":82,"skipped":0,"pct":88.17},"branches":{"total":42,"covered":29,"skipped":0,"pct":69.04}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/design/icons.ts": {"lines":{"total":6,"covered":6,"skipped":0,"pct":100},"functions":{"total":1,"covered":1,"skipped":0,"pct":100},"statements":{"total":7,"covered":7,"skipped":0,"pct":100},"branches":{"total":5,"covered":5,"skipped":0,"pct":100}}
+,"/Users/sethford/Documents/shipwright/dashboard/src/design/tokens.ts": {"lines":{"total":13,"covered":13,"skipped":0,"pct":100},"functions":{"total":0,"covered":0,"skipped":0,"pct":100},"statements":{"total":13,"covered":13,"skipped":0,"pct":100},"branches":{"total":0,"covered":0,"skipped":0,"pct":100}}
+}

package/dashboard/public/index.html

@@ -733,7 +733,7 @@
 
     <!-- Footer -->
     <footer class="footer">
-      <span>Shipwright Fleet Command v2.3.1</span>
+      <span>Shipwright Fleet Command v2.4.0</span>
       <span>Dashboard refreshes via WebSocket</span>
     </footer>
 

package/dashboard/server.ts

@@ -57,6 +57,21 @@ function getDb(): Database | null {
   }
 }
 
+function dbQueryEventsByIdGreaterThan(
+  afterId: number,
+  limit = 100,
+): Array<Record<string, unknown>> {
+  const conn = getDb();
+  if (!conn) return [];
+  try {
+    return conn
+      .query(`SELECT * FROM events WHERE id > ? ORDER BY id ASC LIMIT ?`)
+      .all(afterId, limit) as Array<Record<string, unknown>>;
+  } catch {
+    return [];
+  }
+}
+
 function dbQueryEvents(since?: number, limit = 200): DaemonEvent[] {
   const conn = getDb();
   if (!conn) return [];
@@ -475,6 +490,7 @@ function isPublicRoute(pathname: string): boolean {
     pathname === "/login" ||
     pathname.startsWith("/auth/") ||
     pathname === "/api/health" ||
+    pathname === "/api/ws-status" ||
     pathname.startsWith("/api/join/") ||
     pathname.startsWith("/api/connect/") ||
     pathname === "/api/team" ||
@@ -876,6 +892,8 @@ function appendAuditLog(
 
 // ─── WebSocket client tracking ───────────────────────────────────────
 const wsClients = new Set<import("bun").ServerWebSocket<unknown>>();
+const eventClients = new Set<import("bun").ServerWebSocket<unknown>>();
+let lastBroadcastEventId = 0;
 const startTime = Date.now();
 
 function broadcastToClients(data: FleetState): void {
@@ -889,6 +907,30 @@ function broadcastToClients(data: FleetState): void {
   }
 }
 
+function broadcastNewEvents(): void {
+  if (eventClients.size === 0) return;
+  const db = getDb();
+  if (!db) return;
+  try {
+    const newEvents = dbQueryEventsByIdGreaterThan(lastBroadcastEventId, 100);
+    if (newEvents.length > 0) {
+      const eventMsg = JSON.stringify({ type: "events", data: newEvents });
+      for (const ws of eventClients) {
+        try {
+          ws.send(eventMsg);
+        } catch {
+          eventClients.delete(ws);
+        }
+      }
+      const lastRow = newEvents[newEvents.length - 1];
+      const lastId = (lastRow?.id as number) | 0;
+      if (lastId > 0) lastBroadcastEventId = lastId;
+    }
+  } catch {
+    /* non-fatal */
+  }
+}
+
 // ─── Data Collection ─────────────────────────────────────────────────
 function readEvents(): DaemonEvent[] {
   // Try SQLite first (faster for large event logs)
@@ -917,6 +959,47 @@ function readEvents(): DaemonEvent[] {
 }
 
 function readDaemonState(): Record<string, unknown> | null {
+  // Try DB first
+  try {
+    const conn = getDb();
+    if (conn) {
+      const active = dbQueryJobs("active") as Array<Record<string, unknown>>;
+      const completedRows = conn
+        .query(
+          "SELECT * FROM daemon_state WHERE status IN ('completed', 'failed') ORDER BY completed_at DESC LIMIT 20",
+        )
+        .all() as Array<Record<string, unknown>>;
+      if (active.length > 0 || completedRows.length > 0) {
+        const activeJobs = active.map((j) => ({
+          job_id: j.job_id,
+          issue: j.issue_number,
+          title: j.title || "",
+          stage: j.stage_name || "",
+          started_at: j.started_at,
+          started_epoch: j.started_at
+            ? Math.floor(new Date(j.started_at as string).getTime() / 1000)
+            : 0,
+          worktree: j.worktree || "",
+          branch: j.branch || "",
+          pid: j.pid || 0,
+        }));
+        const completed = completedRows.map((j) => ({
+          issue: j.issue_number,
+          result: j.result || "",
+          duration: j.duration || "",
+          completed_at: j.completed_at || "",
+        }));
+        return {
+          active_jobs: activeJobs,
+          completed,
+          queued: [] as number[],
+        };
+      }
+    }
+  } catch {
+    /* fall through to file */
+  }
+  // Fallback to file
   if (!existsSync(DAEMON_STATE)) return null;
   try {
     return JSON.parse(readFileSync(DAEMON_STATE, "utf-8"));
@@ -1546,7 +1629,63 @@ function getAgents(): AgentInfo[] {
     }
   }
 
-  // Read heartbeat files
+  // Try DB heartbeats first
+  try {
+    const conn = getDb();
+    if (conn) {
+      const rows = dbQueryHeartbeats();
+      if (rows.length > 0) {
+        for (const hb of rows) {
+          const jobId = String(hb.job_id || "");
+          const issue = (hb.issue as number) || 0;
+          const updatedAt = (hb.updated_at as string) || "";
+          let hbEpoch = 0;
+          try {
+            hbEpoch = Math.floor(new Date(updatedAt).getTime() / 1000);
+          } catch {
+            /* ignore */
+          }
+          const age = hbEpoch > 0 ? now - hbEpoch : 9999;
+
+          let status: AgentInfo["status"] = "active";
+          if (age > 120) status = "stale";
+          else if (age > 30) status = "idle";
+
+          const job = issue ? jobMap[issue] : undefined;
+          const startedAt = job ? (job.started_at as string) || "" : updatedAt;
+          let elapsed = 0;
+          if (startedAt) {
+            try {
+              elapsed = now - Math.floor(new Date(startedAt).getTime() / 1000);
+            } catch {
+              /* ignore */
+            }
+          }
+
+          agents.push({
+            id: jobId,
+            issue,
+            title: job ? (job.title as string) || "" : "",
+            machine: (hb.machine as string) || "localhost",
+            stage: (hb.stage as string) || "",
+            iteration: (hb.iteration as number) || 0,
+            activity: (hb.last_activity as string) || "",
+            memory_mb: (hb.memory_mb as number) || 0,
+            cpu_pct: (hb.cpu_pct as number) || 0,
+            status,
+            heartbeat_age_s: age,
+            started_at: startedAt,
+            elapsed_s: elapsed,
+          });
+        }
+        return agents;
+      }
+    }
+  } catch {
+    /* fall through to file */
+  }
+
+  // Fallback: Read heartbeat files
   if (existsSync(HEARTBEAT_DIR)) {
     try {
       const files = readdirSync(HEARTBEAT_DIR).filter((f) =>
@@ -1869,10 +2008,48 @@ interface CostInfo {
   pct_used: number;
 }
 
+function dbQueryBudget(): { dailyBudget: number } {
+  const conn = getDb();
+  if (!conn) return { dailyBudget: 0 };
+  try {
+    const row = conn
+      .query("SELECT daily_budget_usd, enabled FROM budgets WHERE id = 1")
+      .get() as { daily_budget_usd: number; enabled: number } | null;
+    if (!row || row.enabled !== 1) return { dailyBudget: 0 };
+    return { dailyBudget: row.daily_budget_usd || 0 };
+  } catch {
+    return { dailyBudget: 0 };
+  }
+}
+
 function getCostInfo(): CostInfo {
   let todaySpent = 0;
   let dailyBudget = 0;
 
+  // Try DB first
+  try {
+    const conn = getDb();
+    if (conn) {
+      const costs = dbQueryCostsToday();
+      if (costs.count > 0 || costs.total > 0) {
+        todaySpent = Math.round(costs.total * 100) / 100;
+        const budget = dbQueryBudget();
+        dailyBudget = budget.dailyBudget;
+        const pctUsed =
+          dailyBudget > 0
+            ? Math.round((todaySpent / dailyBudget) * 10000) / 100
+            : 0;
+        return {
+          today_spent: todaySpent,
+          daily_budget: dailyBudget,
+          pct_used: pctUsed,
+        };
+      }
+    }
+  } catch {
+    /* fall through to file */
+  }
+
   if (existsSync(COSTS_FILE)) {
     try {
       const data = JSON.parse(readFileSync(COSTS_FILE, "utf-8"));
@@ -2126,6 +2303,7 @@ function startEventsWatcher(): void {
         // Check for new events and send notifications
         if (filename === "events.jsonl") {
           checkAndNotifyNewEvents();
+          broadcastNewEvents();
         }
       }
     });
@@ -2138,15 +2316,22 @@ function startEventsWatcher(): void {
 let lastPushedJson = "";
 
 function periodicPush(): void {
-  if (wsClients.size === 0) return;
+  const hasStateClients = wsClients.size > 0;
+  const hasEventClients = eventClients.size > 0;
 
-  const state = getFleetState();
-  const json = JSON.stringify(state);
-  // Skip push if nothing changed (file watcher already pushed)
-  if (json === lastPushedJson) return;
-  lastPushedJson = json;
+  if (hasStateClients) {
+    const state = getFleetState();
+    const json = JSON.stringify(state);
+    // Skip push if nothing changed (file watcher already pushed)
+    if (json !== lastPushedJson) {
+      lastPushedJson = json;
+      broadcastToClients(state);
+    }
+  }
 
-  broadcastToClients(state);
+  if (hasEventClients) {
+    broadcastNewEvents();
+  }
 }
 
 // ─── GitHub OAuth helpers ───────────────────────────────────────────
@@ -2397,6 +2582,24 @@ const server = Bun.serve({
       });
     }
 
+    // GET /api/ws-status — WebSocket connection status (for evidence collection)
+    if (pathname === "/api/ws-status" && req.method === "GET") {
+      const clients = wsClients?.size ?? 0;
+      return new Response(
+        JSON.stringify({
+          status: "ok",
+          websocket: {
+            active_connections: clients,
+            server_running: true,
+          },
+          timestamp: new Date().toISOString(),
+        }),
+        {
+          headers: { "Content-Type": "application/json", ...CORS_HEADERS },
+        },
+      );
+    }
+
     // GET /api/join/{token} — Serve join script (public, no auth required)
     if (pathname.startsWith("/api/join/") && req.method === "GET") {
       const token = pathname.split("/")[3] || "";
@@ -2492,7 +2695,7 @@ const server = Bun.serve({
       const session = getSession(req);
       if (!session) {
         // WebSocket upgrade attempt without auth
-        if (pathname === "/ws") {
+        if (pathname === "/ws" || pathname === "/ws/events") {
           return new Response("Unauthorized", { status: 401 });
         }
         return new Response(null, {
@@ -2504,7 +2707,14 @@ const server = Bun.serve({
 
     // ── Protected routes ──────────────────────────────────────────
 
-    // WebSocket upgrade
+    // WebSocket upgrade — /ws/events streams raw events, /ws streams aggregated state
+    if (pathname === "/ws/events") {
+      const upgraded = server.upgrade(req, {
+        data: { type: "events", lastEventId: 0 },
+      });
+      if (upgraded) return undefined as unknown as Response;
+      return new Response("WebSocket upgrade failed", { status: 400 });
+    }
     if (pathname === "/ws") {
       const upgraded = server.upgrade(req);
       if (upgraded) return undefined as unknown as Response;
@@ -5289,6 +5499,68 @@ const server = Bun.serve({
           );
         }
 
+        // VERIFY: re-read labels — if competing claimed:* labels exist, we lost the race
+        try {
+          const verifyLabels = execSync(
+            `gh issue view ${issue}${repoFlag} --json labels -q '.labels[].name'`,
+            {
+              encoding: "utf-8",
+              timeout: 10000,
+              stdio: ["pipe", "pipe", "pipe"],
+            },
+          )
+            .trim()
+            .split("\n")
+            .filter((l: string) => l.startsWith("claimed:"));
+          if (
+            verifyLabels.length !== 1 ||
+            verifyLabels[0] !== `claimed:${machine}`
+          ) {
+            // Competing claim — remove ours and reject
+            execSync(
+              `gh issue edit ${issue}${repoFlag} --remove-label "claimed:${machine}"`,
+              { timeout: 10000, stdio: ["pipe", "pipe", "pipe"] },
+            );
+            return new Response(
+              JSON.stringify({
+                approved: false,
+                claimed_by:
+                  verifyLabels[0]?.replace("claimed:", "") || "another machine",
+                error: "Claim race lost",
+              }),
+              {
+                headers: {
+                  "Content-Type": "application/json",
+                  ...CORS_HEADERS,
+                },
+              },
+            );
+          }
+        } catch {
+          // Verification failed — conservative: remove our label and reject
+          try {
+            execSync(
+              `gh issue edit ${issue}${repoFlag} --remove-label "claimed:${machine}"`,
+              { timeout: 10000, stdio: ["pipe", "pipe", "pipe"] },
+            );
+          } catch {
+            /* best-effort cleanup */
+          }
+          return new Response(
+            JSON.stringify({
+              approved: false,
+              error: "Claim verification failed",
+            }),
+            {
+              status: 500,
+              headers: {
+                "Content-Type": "application/json",
+                ...CORS_HEADERS,
+              },
+            },
+          );
+        }
+
         return new Response(
           JSON.stringify({ approved: true, claimed_by: machine }),
           {
@@ -5473,12 +5745,20 @@ const server = Bun.serve({
 
   websocket: {
     open(ws) {
-      wsClients.add(ws);
-      // Send initial state immediately on connect
-      try {
-        ws.send(JSON.stringify(getFleetState()));
-      } catch {
-        wsClients.delete(ws);
+      const data = ws.data as
+        | { type?: string; lastEventId?: number }
+        | undefined;
+      if (data?.type === "events") {
+        eventClients.add(ws);
+        // Event clients get events via broadcastNewEvents; no initial state
+      } else {
+        wsClients.add(ws);
+        // Send initial state immediately on connect
+        try {
+          ws.send(JSON.stringify(getFleetState()));
+        } catch {
+          wsClients.delete(ws);
+        }
       }
     },
     message(_ws, _message) {
@@ -5486,6 +5766,7 @@ const server = Bun.serve({
     },
     close(ws) {
       wsClients.delete(ws);
+      eventClients.delete(ws);
     },
   },
 });
@@ -5572,7 +5853,15 @@ process.on("SIGINT", () => {
       // ignore
     }
   }
+  for (const ws of eventClients) {
+    try {
+      ws.close(1001, "Server shutting down");
+    } catch {
+      // ignore
+    }
+  }
   wsClients.clear();
+  eventClients.clear();
   server.stop();
   process.exit(0);
 });
@@ -5597,7 +5886,7 @@ console.log(
   `  ${GREEN}\u25CF${RESET} API:       ${ULINE}http://localhost:${server.port}/api/status${RESET}`,
 );
 console.log(
-  `  ${GREEN}\u25CF${RESET} WebSocket: ${ULINE}ws://localhost:${server.port}/ws${RESET}`,
+  `  ${GREEN}\u25CF${RESET} WebSocket: ${ULINE}ws://localhost:${server.port}/ws${RESET} | ${ULINE}/ws/events${RESET}`,
 );
 console.log(
   `  ${GREEN}\u25CF${RESET} Health:    ${ULINE}http://localhost:${server.port}/api/health${RESET}`,