Method parse_event

atomic-agent/src/hooks/grok.rs:171–224

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

    }

    fn parse_event(&self, hook_type: HookType, input: &[u8]) -> AgentResult<TurnEvent> {
        let raw_json = self.parse_json(hook_type, input)?;
        let parsed = self.parse_common(hook_type, raw_json.clone())?;

        let mut raw_json = with_xai_provider(raw_json);
        if hook_type == HookType::TurnEnd {
            raw_json = normalize_stop_raw(raw_json, parsed.reason.as_deref());
        }
        if hook_type == HookType::PostToolUse {
            raw_json = normalize_tool_raw(raw_json, parsed.tool_result.as_ref());
        }

        // Promote model/provider into raw_json when present (orchestrator reads them).
        if let Some(model) = parsed.model.as_ref() {
            insert_if_missing(&mut raw_json, "model", Value::String(model.clone()));
        }
        if let Some(provider) = parsed.provider.as_ref() {
            insert_if_missing(&mut raw_json, "provider", Value::String(provider.clone()));
        }

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

        if let Some(path) = parsed.transcript_path.filter(|p| !p.is_empty()) {
            event = event.with_transcript_path(path);
        }

        match hook_type {
            HookType::TurnStart => {
                if let Some(prompt) = parsed.prompt.filter(|p| !p.is_empty()) {
                    // Grok's UserPromptSubmit often wraps the human text in
                    // `<user_query>…</user_query>` (harness envelope). That
                    // raw string would otherwise become the Atomic change
                    // message (`atomic log` shows the tags). Strip it so
                    // provenance and the commit message carry the real text.
                    let prompt = normalize_user_prompt(&prompt);
                    if !prompt.is_empty() {
                        event = event.with_prompt(prompt);
                    }
                }
            }
            HookType::PreToolUse | HookType::PostToolUse => {
                if let Some(name) = parsed.tool_name.filter(|n| !n.is_empty()) {
                    event = event.with_tool_name(name);
                }
                if let Some(id) = parsed.tool_use_id.filter(|id| !id.is_empty()) {
                    event = event.with_tool_use_id(id);
                }
            }
            HookType::SessionStart | HookType::SessionEnd | HookType::TurnEnd => {}
        }

        Ok(event)
    }

    fn install(&self, _repo_root: &Path) -> AgentResult<usize> {
        // Installation is handled by the atomic-grok package via the