fix(inspector): round 2 — type names, session id, pech, tracing log, details

- Event::type_str() returns the real wire-side `type` for Unknown variants
  (pech.ledger.appended, lifecycle.*, mcp.tool.*, ...) instead of the
  static "unknown" placeholder. Events table column now reads usefully.
  type_tag() preserved for the &'static str callers (events/security/
  replay/plugins views).
- AppState::apply() latches session.session_id on the first event that
  carries one, then locks it. ACTIVE SESSION's "Session" row stops
  showing "-" the moment any wire event lands.
- pech.ledger.appended in apply_unknown now bumps pech.last_event
  explicitly. The runtime stamps these events with `plugin: "mcp-client"`,
  so the generic ev.plugin() refresh credits mcp-client; without the
  explicit bump pech's "last seen" never ticked.
- fmt_log_size: 0 renders as "0 B" (was "-"); ladder boundaries verified
  at 0 / 999 / 1024 / 1MB / 1GB. Path resolution to %LOCALAPPDATA%/
  enchanter/inspector.log confirmed correct — the displayed 38 GB is
  honest (real log is 40 GB on this machine; rotation is a separate bug).
- event_detail / unknown_event_detail: priority chain pulls
  message → extras["message"] → extras["reason"] → type-specific synthesis
  (pech.ledger.appended → cost+tokens, mcp.tool.call.requested → tool+path,
  lifecycle.* → phase+elapsed, *.veto.* → policy/reason) → JSON-stringify
  fallback truncated to 60 chars. Details column populated for every row.

+6 tests: type_str x2, session_id_latches, pech_ledger_last_event,
unknown_event_detail_priority_chain, event_detail_pech_typed.

Author: klaiderman

inspector/src/event.rs

@@ -7,6 +7,7 @@
 //! parser keeps making progress when the runtime adds new fields.
 
 use serde::{Deserialize, Serialize};
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 
 /// Severity ladder shared by veto / review / drift events.
@@ -369,6 +370,22 @@ impl Event {
         }
     }
 
+    /// Real wire-format type string. Identical to `type_tag()` for typed
+    /// variants, but for `Event::Unknown` returns the original `type` field
+    /// pulled from `GenericPayload.extra` (preserved by `parse_line`'s
+    /// fallback path) rather than the static `"unknown"` placeholder. This
+    /// is what the events-table renderer wants — `pech.ledger.appended`
+    /// is more useful to a human reader than `unknown`.
+    pub fn type_str(&self) -> Cow<'_, str> {
+        match self {
+            Event::Unknown(p) => match p.extra.get("type").and_then(|v| v.as_str()) {
+                Some(s) if !s.is_empty() => Cow::Borrowed(s),
+                _ => Cow::Borrowed("unknown"),
+            },
+            _ => Cow::Borrowed(self.type_tag()),
+        }
+    }
+
     /// Plugin attribution if the event carries one.
     pub fn plugin(&self) -> Option<&str> {
         match self {
@@ -759,6 +776,24 @@ mod tests {
         }
     }
 
+    #[test]
+    fn type_str_returns_real_type_for_unknown_variant() {
+        // Round-2 fix: Event::Unknown's type_tag() returns "unknown", which
+        // makes the events table column useless. type_str() must pull the
+        // real wire-side `type` field from the flattened payload extras.
+        let json = r#"{"type": "pech.ledger.appended", "time": 1.0, "plugin": "mcp-client"}"#;
+        let evt = parse_line(json).expect("expected fallback to Event::Unknown");
+        assert_eq!(evt.type_tag(), "unknown");
+        assert_eq!(evt.type_str(), "pech.ledger.appended");
+    }
+
+    #[test]
+    fn type_str_matches_type_tag_for_typed_variants() {
+        let evt = Event::sample_runtime_metrics_with_open_sessions(0);
+        assert_eq!(evt.type_str(), "runtime.metrics");
+        assert_eq!(evt.type_str(), evt.type_tag());
+    }
+
     #[test]
     fn pech_ledger_roundtrip() {
         let json = r#"{

inspector/src/state.rs

@@ -1139,6 +1139,23 @@ impl AppState {
 
     /// Apply a single event to the state.
     pub fn apply(&mut self, ev: Event) {
+        // Lock-on-first-set: the inspector tracks one session at a time. As
+        // soon as any event arrives carrying a non-empty `session_id`, latch
+        // it onto the session pane so ACTIVE SESSION's "Session" row stops
+        // showing "-". Subsequent events (which may belong to other sessions
+        // when the runtime fans out) do not overwrite — multi-session display
+        // is a future concern.
+        if self.session.session_id.is_empty()
+            || self.session.session_id == "-"
+            || self.session.session_id == "unknown"
+        {
+            if let Some(sid) = ev.session_id() {
+                if !sid.is_empty() {
+                    self.session.session_id = sid.to_string();
+                }
+            }
+        }
+
         match &ev {
             // ---- runtime.metrics ----------------------------------------
             Event::RuntimeMetrics {
@@ -1626,16 +1643,23 @@ impl AppState {
                     .get("daily_cost_usd")
                     .and_then(|v| v.as_f64())
                     .unwrap_or(0.0);
-                self.metrics.spent_session_usd = session_cost;
+                if session_cost > 0.0 {
+                    self.metrics.spent_session_usd = session_cost;
+                }
                 if daily > 0.0 {
                     self.budgets.daily_spend_usd = daily;
                 }
-                self.set_plugin_display("pech", format!("${:.2}", session_cost));
+                self.set_plugin_display("pech", format!("${:.2}", self.metrics.spent_session_usd));
                 let cents = (cost_usd * 100.0).round().max(0.0) as u64;
                 self.push_plugin_usage("pech", cents);
+                // Bump pech's call counter and last_event regardless of the
+                // wire-side `plugin` field — the runtime emits these events
+                // with `plugin: "mcp-client"`, so the generic ev.plugin()
+                // refresh below would credit mcp-client, not pech.
                 if let Some(idx) = self.plugin_index_by_name("pech") {
                     let plug = &mut self.plugins[idx];
                     plug.calls = plug.calls.saturating_add(1);
+                    plug.last_event = Some(p.time);
                 }
             }
             "hydra.veto.fired" => {
@@ -2158,6 +2182,96 @@ mod tests {
         assert_eq!(s.session.current_phase, Some(crate::event::Phase::TrustGate));
     }
 
+    #[test]
+    fn session_id_latches_on_first_event_carrying_one() {
+        // Round-2 fix #2: ACTIVE SESSION shows "-" until any event lands a
+        // non-empty session_id. After the latch, subsequent events do NOT
+        // overwrite (lock-on-first-set) so multi-session fan-out doesn't
+        // corrupt the displayed session.
+        let mut s = AppState::new();
+        assert!(s.session.session_id.is_empty());
+
+        // Event 1 carries session_id=abc123 — latch.
+        let mut p1 = crate::event::GenericPayload {
+            time: 1.0,
+            session_id: Some("abc123".into()),
+            task_id: None,
+            plugin: Some("orchestrator".into()),
+            phase: None,
+            severity: None,
+            message: None,
+            extra: std::collections::BTreeMap::new(),
+        };
+        p1.extra.insert("type".into(), serde_json::json!("lifecycle.anchor"));
+        s.apply(Event::Unknown(p1));
+        assert_eq!(s.session.session_id, "abc123");
+
+        // Event 2 carries session_id=def456 — must NOT overwrite.
+        let mut p2 = crate::event::GenericPayload {
+            time: 2.0,
+            session_id: Some("def456".into()),
+            task_id: None,
+            plugin: Some("orchestrator".into()),
+            phase: None,
+            severity: None,
+            message: None,
+            extra: std::collections::BTreeMap::new(),
+        };
+        p2.extra.insert("type".into(), serde_json::json!("lifecycle.dispatch"));
+        s.apply(Event::Unknown(p2));
+        assert_eq!(s.session.session_id, "abc123", "session_id must lock on first set");
+
+        // Event 3: an event with no session_id is fine — latched value stays.
+        let mut p3 = crate::event::GenericPayload {
+            time: 3.0,
+            session_id: None,
+            task_id: None,
+            plugin: None,
+            phase: None,
+            severity: None,
+            message: None,
+            extra: std::collections::BTreeMap::new(),
+        };
+        p3.extra.insert("type".into(), serde_json::json!("totally.fake"));
+        s.apply(Event::Unknown(p3));
+        assert_eq!(s.session.session_id, "abc123");
+    }
+
+    #[test]
+    fn pech_ledger_appended_updates_last_event_even_when_wire_plugin_is_mcp_client() {
+        // Round-2 fix #3: the runtime emits pech.ledger.appended with
+        // `plugin: "mcp-client"`, not `plugin: "pech"`. The generic
+        // ev.plugin() refresh credits mcp-client's last_event, so pech's
+        // own last_event would never tick. Verify the explicit pech-side
+        // last_event update fires.
+        let mut s = AppState::new();
+        let mut extra = std::collections::BTreeMap::new();
+        extra.insert("type".into(), serde_json::json!("pech.ledger.appended"));
+        extra.insert("session_cost_usd".into(), serde_json::json!(0.42));
+        extra.insert("cost_usd".into(), serde_json::json!(0.05));
+        extra.insert("daily_cost_usd".into(), serde_json::json!(3.21));
+        extra.insert("input_tokens".into(), serde_json::json!(1200));
+        extra.insert("output_tokens".into(), serde_json::json!(380));
+        let ev = Event::Unknown(crate::event::GenericPayload {
+            time: 1_778_086_945.5,
+            session_id: Some("sess-x".into()),
+            task_id: None,
+            plugin: Some("mcp-client".into()), // <-- the live wire shape
+            phase: Some("post-response".into()),
+            severity: None,
+            message: None,
+            extra,
+        });
+        s.apply(ev);
+
+        assert!((s.metrics.spent_session_usd - 0.42).abs() < 1e-9);
+        assert!((s.budgets.daily_spend_usd - 3.21).abs() < 1e-9);
+        let pech = s.plugins.iter().find(|p| p.name == "pech").unwrap();
+        assert_eq!(pech.display_value, "$0.42");
+        assert_eq!(pech.calls, 1);
+        assert_eq!(pech.last_event, Some(1_778_086_945.5));
+    }
+
     #[test]
     fn unknown_event_with_plugin_refreshes_last_event() {
         let mut s = AppState::new();