Keep the engine's own history, and a screen that reads it

A second bus subscriber folds executions, errors, timings and queue lag
into per-minute rollups, keeps failures with their traceback and an audit
trail of who published what, and records one row per cascade — manual runs
and previews included, under an id of their own that writes no idempotency
markers. Read back through /observability/*, which always answers 200 so a
degraded engine still renders its own health screen.

Also fixes two things found on the way: node-health alerts read `status`
where the engine publishes `health`, so a device dropping never alerted
anyone, and the Redis queue reported `parked: 0` whatever was held.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017MeiWk3Yq12n2pTvnQWYvt

frontend/src/components/Flow/liveStore.ts

@@ -24,6 +24,19 @@ export type LiveStatus = {
   status: "active" | "error" | "running" | "success"
   error?: string | null
 }
+/** How a node's connection is doing, which is not how its last run went. */
+export type NodeHealth = {
+  health: "ok" | "down" | "unknown"
+  detail?: string | null
+}
+/** Something the engine reported about itself, for the health page. */
+export type EngineEvent = {
+  type: string
+  flow?: string
+  node?: string
+  detail?: string
+  ts: number
+}
 /** One node execution's output, as the log panel shows it. */
 export type LogLine = {
   flow: string
@@ -38,9 +51,13 @@ type Listener = () => void
 
 /** Enough to see what a flow has been doing, not a log store. */
 const LOG_LIMIT = 500
+/** The health page reads these to know when to refetch; it is not a history. */
+const ENGINE_EVENT_LIMIT = 100
 
 const values = new Map<string, LiveValue>()
 const statuses = new Map<string, LiveStatus>()
+const health = new Map<string, NodeHealth>()
+let engineEvents: EngineEvent[] = []
 // How many times a node has emitted. The number itself means nothing; a change
 // is what restarts the pulse.
 const emits = new Map<string, number>()
@@ -100,6 +117,18 @@ export const liveStore = {
   getStatus(nodeId: string) {
     return statuses.get(nodeId)
   },
+  setHealth(nodeId: string, entry: NodeHealth) {
+    health.set(nodeId, entry)
+    notify(`health:${nodeId}`)
+  },
+  getHealth(nodeId: string) {
+    return health.get(nodeId)
+  },
+  recordEngineEvent(event: EngineEvent) {
+    // A new array each time, so the hook's snapshot comparison sees the change.
+    engineEvents = [...engineEvents, event].slice(-ENGINE_EVENT_LIMIT)
+    notify("engine")
+  },
   recordEmit(nodeId: string) {
     emits.set(nodeId, (emits.get(nodeId) ?? 0) + 1)
     notify(`emit:${nodeId}`)
@@ -146,6 +175,10 @@ export const liveStore = {
     statuses.clear()
     for (const key of emits.keys()) notify(`emit:${key}`)
     emits.clear()
+    for (const key of health.keys()) notify(`health:${key}`)
+    health.clear()
+    engineEvents = []
+    notify("engine")
     logLines = []
     notify("logs")
     for (const flow of paused) notify(`paused:${flow}`)
@@ -167,6 +200,22 @@ export function useNodeStatus(nodeId: string): LiveStatus | undefined {
   )
 }
 
+/** How the node's connection is doing, once it has said anything about it. */
+export function useNodeHealth(nodeId: string): NodeHealth | undefined {
+  return useSyncExternalStore(
+    (listener) => subscribeKey(`health:${nodeId}`, listener),
+    () => health.get(nodeId),
+  )
+}
+
+/** The last hundred things the engine said about itself, oldest first. */
+export function useEngineEvents(): EngineEvent[] {
+  return useSyncExternalStore(
+    (listener) => subscribeKey("engine", listener),
+    () => engineEvents,
+  )
+}
+
 /** Increments each time the node publishes something. */
 export function useNodeEmits(nodeId: string): number {
   return useSyncExternalStore(