fix(observability): cockpit was silent — schema rejected real events

User report: "uptime ticks but nothing happens, doesn't even listen
to the MCP server." Two compounding bugs:

1. **Permissive schema for unknown types.** docs/event-schema.json's
   genericVariant pinned `type` to a 28-element enum drawn from the
   Rust event.rs allowlist. The actual orchestrator + plugins emit
   names that AREN'T in that list — `lifecycle.anchor`,
   `mcp.tool.call.requested`, `crow.trust.scored`, `pech.ledger.appended`,
   `hydra.veto.fired`, etc. Schema validator dropped every line
   silently. Fix: type is `{ type: "string" }` with no enum constraint;
   well-typed variants in oneOf still strict.

2. **Rust parse_line falls back on unknown discriminator.** event.rs
   was a strict serde-tagged enum — any `type` value not in the
   variant list returned a parse error. Added Event::Unknown(GenericPayload)
   marked #[serde(skip)] so serde never tries to dispatch it directly,
   and parse_line tries the strict variant first, falls through to
   GenericPayload-wrapped Unknown on failure. The cockpit now surfaces
   every event in the events table, regardless of whether we have a
   typed variant for it.

Verified: 7728 bytes of real events flow through stdout from a 30s
live.ts run, where before it was 0 bytes.

Author: klaiderman

docs/event-schema.json

@@ -25,45 +25,11 @@
       "minimum": 0
     },
     "genericVariant": {
-      "description": "Loose-shape variants flowing through Rust GenericPayload. Required: type, time. Optional common fields are recognized; unknown fields round-trip via additionalProperties:true.",
+      "description": "Permissive fallback for any event whose type isn't well-typed in the oneOf below. Required: type (any string), time. Both producer (TS) and consumer (Rust) accept any type string here so wire-format extensions don't require a schema bump in lockstep. The Rust GenericPayload mirrors this — unknown discriminators round-trip via the flattened extras map.",
       "type": "object",
       "required": ["type", "time"],
       "properties": {
-        "type": {
-          "type": "string",
-          "enum": [
-            "session.started",
-            "session.opened",
-            "session.closed",
-            "session.ended",
-            "phase.entered",
-            "phase.completed",
-            "plugin.loaded",
-            "plugin.health",
-            "tool.result",
-            "tool.error",
-            "sylph.veto",
-            "crow.trust",
-            "djinn.anchor",
-            "djinn.drift",
-            "gorgon.hotspot",
-            "naga.spec_check",
-            "lich.review",
-            "emu.context_update",
-            "task.created",
-            "task.started",
-            "task.blocked",
-            "task.completed",
-            "task.failed",
-            "code.generated",
-            "file.created",
-            "file.modified",
-            "test.run",
-            "test.passed",
-            "test.failed",
-            "pr.created"
-          ]
-        },
+        "type": { "type": "string" },
         "time": { "$ref": "#/definitions/time" },
         "session_id": { "type": "string" },
         "task_id": { "type": "string" },

inspector/src/event.rs

@@ -267,6 +267,15 @@ pub enum Event {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         payload: Option<serde_json::Value>,
     },
+    /// Catch-all for events whose `type` discriminator isn't in the explicit
+    /// list above. The producer (TS bridge) emits many `lifecycle.*`,
+    /// `mcp.tool.*`, `*.appended`, `*.fired`, `*.scored` event names that the
+    /// Rust enum hasn't enumerated. Without this, `parse_line` would error and
+    /// the transport's malformed-line counter would tick on every emit.
+    /// Populated by `parse_line` via fallback parse to `GenericPayload` —
+    /// never by direct serde dispatch (hence `#[serde(skip)]`).
+    #[serde(skip)]
+    Unknown(GenericPayload),
 }
 
 impl Event {
@@ -281,6 +290,8 @@ impl Event {
             | Event::CodeModified { time, .. }
             | Event::RequestApproval { time, .. } => *time,
 
+            Event::Unknown(p) => p.time,
+
             Event::SessionStarted(p)
             | Event::SessionOpened(p)
             | Event::SessionClosed(p)
@@ -354,6 +365,7 @@ impl Event {
             Event::TestFailed(_) => "test.failed",
             Event::PrCreated(_) => "pr.created",
             Event::RequestApproval { .. } => "request.approval",
+            Event::Unknown(_) => "unknown",
         }
     }
 
@@ -400,6 +412,8 @@ impl Event {
             | Event::TestPassed(p)
             | Event::TestFailed(p)
             | Event::PrCreated(p) => p.plugin.as_deref(),
+
+            Event::Unknown(p) => p.plugin.as_deref(),
         }
     }
 
@@ -446,6 +460,8 @@ impl Event {
             | Event::TestPassed(p)
             | Event::TestFailed(p)
             | Event::PrCreated(p) => p.session_id.as_deref(),
+
+            Event::Unknown(p) => p.session_id.as_deref(),
         }
     }
 
@@ -492,6 +508,8 @@ impl Event {
             | Event::TestPassed(p)
             | Event::TestFailed(p)
             | Event::PrCreated(p) => p.task_id.as_deref(),
+
+            Event::Unknown(p) => p.task_id.as_deref(),
         }
     }
 
@@ -537,15 +555,29 @@ impl Event {
             | Event::TestPassed(p)
             | Event::TestFailed(p)
             | Event::PrCreated(p) => p.severity,
+
+            Event::Unknown(p) => p.severity,
         }
     }
 }
 
 /// Tolerant single-line parser. Bubbles up errors (including unknown
 /// discriminants) so the caller can log and skip, never panic.
 pub fn parse_line(line: &str) -> anyhow::Result<Event> {
-    let event = serde_json::from_str::<Event>(line)?;
-    Ok(event)
+    // Try the strict tagged-enum parse first.
+    match serde_json::from_str::<Event>(line) {
+        Ok(event) => Ok(event),
+        Err(strict_err) => {
+            // Fall back to GenericPayload for events whose `type` discriminator
+            // isn't in our explicit variant list. The producer emits many event
+            // names (`lifecycle.*`, `mcp.tool.*`, `*.appended`, `*.fired`) that
+            // we don't model individually but still want to surface in the UI.
+            match serde_json::from_str::<GenericPayload>(line) {
+                Ok(payload) => Ok(Event::Unknown(payload)),
+                Err(_) => Err(anyhow::Error::from(strict_err).context("event parse failed")),
+            }
+        }
+    }
 }
 
 #[cfg(test)]

inspector/src/views/overview.rs

@@ -929,6 +929,8 @@ fn event_phase(ev: &Event) -> Option<String> {
         | Event::TestFailed(p)
         | Event::PrCreated(p) => p.phase.clone(),
 
+        Event::Unknown(p) => p.phase.clone(),
+
         Event::RuntimeMetrics { .. } | Event::CodeModified { .. } => None,
     }
 }