fix(parser): handle parentUuid: null in subagent JSONL entries

parse_entry skipped any line where serde_json failed to deserialize.
The first entry in every subagent JSONL file has parentUuid: null, which
caused serde to fail because #[serde(default)] only applies to absent
fields — not fields explicitly set to null.

Result: the skill-prompt user message (first line) was silently dropped.
proc.prompt stayed empty, orphan_description_from_prompt returned "",
and subagent_desc was never populated — so detail-item__summary showed
nothing for all Skill-forked agents.

Fix: add a null_as_default deserializer for parent_uuid that treats
null as an empty string (same as absent). Add a regression test in
entry.rs and an end-to-end integration test (skill_forked_agents_have_
subagent_desc_populated) that loads the real session 3f97c7ca and
asserts all 6 agent items carry their skill name as subagent_desc.

Author: delexw

src-tauri/src/convert.rs

@@ -810,4 +810,69 @@ mod tests {
         assert_eq!(result.len(), 1);
         assert_eq!(result[0].subagent_prompt, "");
     }
+
+    /// End-to-end test using the real JSONL session 3f97c7ca to verify that
+    /// Skill-forked agent summaries (detail-item__summary) are populated.
+    /// The session has no assistant messages — all 6 agents are orphans linked
+    /// via inject_orphan_subagents + the convert_display_items fallback.
+    #[test]
+    fn skill_forked_agents_have_subagent_desc_populated() {
+        use crate::parser::chunk::build_chunks;
+        use crate::parser::session::read_session_with_debug_hooks;
+        use crate::parser::subagent::{discover_and_link_all, inject_orphan_subagents};
+
+        let session_path = concat!(
+            env!("HOME"),
+            "/.claude/projects",
+            "/-Users-yang-liu--dovepaw-workspaces--oncall-analyzer-oa-0104cf01",
+            "/3f97c7ca-41e5-4a0d-b20e-beea73a63aa1.jsonl"
+        );
+
+        // Skip if the session doesn't exist on this machine.
+        if !std::path::Path::new(session_path).exists() {
+            return;
+        }
+
+        let (classified, _, _) = read_session_with_debug_hooks(session_path).unwrap();
+        let mut chunks = build_chunks(&classified);
+        let (mut all_procs, color_map) = discover_and_link_all(session_path, &chunks);
+        inject_orphan_subagents(&mut chunks, &mut all_procs);
+
+        let messages = chunks_to_messages(&chunks, &all_procs, &color_map);
+
+        // Collect all Subagent items across all messages.
+        let agent_items: Vec<_> = messages
+            .iter()
+            .flat_map(|m| m.items.iter())
+            .filter(|it| it.item_type == "Subagent")
+            .collect();
+
+        assert!(
+            !agent_items.is_empty(),
+            "session must produce at least one Subagent item"
+        );
+
+        let expected_skills = [
+            "rollbar-reader",
+            "pagerduty-oncall",
+            "datadog-analyser",
+            "slack-explorer",
+            "cloudflare-traffic-investigator",
+            "pir",
+        ];
+
+        for item in &agent_items {
+            assert!(
+                !item.subagent_desc.is_empty(),
+                "subagent_desc must not be empty (agent_id={})",
+                item.agent_id
+            );
+            assert!(
+                expected_skills.contains(&item.subagent_desc.as_str()),
+                "subagent_desc '{}' must be a known skill name (agent_id={})",
+                item.subagent_desc,
+                item.agent_id
+            );
+        }
+    }
 }

src-tauri/src/parser/entry.rs

@@ -2,14 +2,25 @@ use serde::Deserialize;
 use serde_json::Value;
 use std::collections::HashMap;
 
+/// Deserializes a JSON string field, treating `null` as the type's default
+/// value. Serde's `#[serde(default)]` only applies when the field is absent;
+/// this helper also handles the `"field": null` case.
+fn null_as_default<'de, D, T>(d: D) -> Result<T, D::Error>
+where
+    D: serde::Deserializer<'de>,
+    T: Default + Deserialize<'de>,
+{
+    Ok(Option::<T>::deserialize(d)?.unwrap_or_default())
+}
+
 /// Entry represents a raw JSONL line from a Claude Code session file.
 #[derive(Debug, Deserialize, Default)]
 pub struct Entry {
     #[serde(default, rename = "type")]
     pub entry_type: String,
     #[serde(default)]
     pub uuid: String,
-    #[serde(default, rename = "parentUuid")]
+    #[serde(default, rename = "parentUuid", deserialize_with = "null_as_default")]
     pub parent_uuid: String,
     #[serde(default)]
     pub timestamp: String,
@@ -207,4 +218,22 @@ mod tests {
         };
         assert!(e.tool_use_result_map().is_none());
     }
+
+    #[test]
+    fn parse_entry_handles_null_parent_uuid() {
+        // Subagent JSONL files write parentUuid: null for the first entry.
+        // parse_entry must succeed and treat null as an empty string.
+        let line = json!({
+            "type": "user",
+            "uuid": "e65f5102-fdbe-424d-814f-a04e1ab466c6",
+            "parentUuid": null,
+            "isSidechain": true,
+            "timestamp": "2026-04-12T21:18:39.485Z",
+            "message": {"role": "user", "content": "Base directory for this skill: /skills/test"}
+        });
+        let bytes = serde_json::to_vec(&line).unwrap();
+        let entry = parse_entry(&bytes).expect("must parse despite null parentUuid");
+        assert_eq!(entry.parent_uuid, "");
+        assert_eq!(entry.entry_type, "user");
+    }
 }