Method parse_event

atomic-agent/src/hooks/cursor.rs:397–705

(&self, hook_type: HookType, input: &[u8])

    }

    fn parse_event(&self, hook_type: HookType, input: &[u8]) -> AgentResult<TurnEvent> {
        if input.is_empty() {
            return Err(AgentError::HookInputEmpty {
                agent: self.name().to_string(),
                hook_type: hook_type.as_str().to_string(),
            });
        }

        // Preserve raw JSON for debugging and downstream use
        let raw_json: serde_json::Value =
            serde_json::from_slice(input).map_err(|e| AgentError::HookParseFailed {
                agent: self.name().to_string(),
                hook_type: hook_type.as_str().to_string(),
                reason: e.to_string(),
            })?;

        match hook_type {
            HookType::SessionStart => {
                let parsed: SessionStartInput =
                    serde_json::from_value(raw_json.clone()).map_err(|e| {
                        AgentError::HookParseFailed {
                            agent: self.name().to_string(),
                            hook_type: hook_type.as_str().to_string(),
                            reason: e.to_string(),
                        }
                    })?;

                // SessionStart: prefer session_id, fall back to conversation_id
                let session_id =
                    Self::extract_session_id(parsed.conversation_id, parsed.session_id);

                let mut event = TurnEvent::new(session_id, hook_type).with_raw_json(raw_json);

                if let Some(transcript) = parsed.transcript_path {
                    event = event.with_transcript_path(transcript);
                }

                // Store model, composer_mode, is_background_agent in raw_json
                if let Some(model) = parsed.model {
                    if let Some(ref mut raw) = event.raw_json {
                        if let Some(obj) = raw.as_object_mut() {
                            obj.insert("model".to_string(), serde_json::Value::String(model));
                        }
                    }
                }
                if let Some(mode) = parsed.composer_mode {
                    if let Some(ref mut raw) = event.raw_json {
                        if let Some(obj) = raw.as_object_mut() {
                            obj.insert(
                                "composer_mode".to_string(),
                                serde_json::Value::String(mode),
                            );
                        }
                    }
                }
                if let Some(bg) = parsed.is_background_agent {
                    if let Some(ref mut raw) = event.raw_json {
                        if let Some(obj) = raw.as_object_mut() {