Method fire

core/src/ahp/executor.rs:823–877

(&self, event: &HookEvent)

#[async_trait]
impl HookExecutor for AhpHookExecutor {
    async fn fire(&self, event: &HookEvent) -> HookResult {
        // Record this event (updates activity timestamp and counter)
        self.record_event();
        self.record_hook_event_state(event);

        // Map to AHP event
        let ahp_event = match self.map_event(event) {
            Some(e) => e,
            None => {
                // Event not mapped to AHP, allow by default
                debug!("Event {:?} not mapped to AHP, allowing", event.event_type());
                return HookResult::Continue(None);
            }
        };

        // Check if this is a blocking event
        let is_blocking = self.is_blocking_event(event.event_type());

        if is_blocking {
            // Flush any pending batch before sending blocking event
            if self.batch_enabled {
                self.flush_batch().await;
            }

            // Send event and wait for decision
            match self.client.send_event_full(&ahp_event).await {
                Ok(decision) => {
                    let decision_payload = serde_json::to_value(decision).unwrap_or_default();
                    debug!(
                        "AHP decision for {:?}: {:?}",
                        ahp_event.event_type, decision_payload
                    );
                    self.map_decision(ahp_event.event_type, decision_payload)
                }
                Err(e) => {
                    warn!("AHP error: {}, allowing by default", e);
                    HookResult::Continue(None)
                }
            }
        } else if self.batch_enabled {
            // Batch mode: accumulate non-blocking events
            self.add_to_batch(ahp_event).await;
            HookResult::Continue(None)
        } else {
            // Fire-and-forget for non-blocking events.
            let client = self.client.clone();
            let event = ahp_event;
            tokio::spawn(async move {
                if let Err(e) = client.send_event_full(&event).await {
                    warn!("AHP fire-and-forget error: {}", e);
                }
            });
            HookResult::Continue(None)
        }
    }

    async fn record_agent_event(&self, event: &AgentEvent, run_id: &str, session_id: &str) {
        self.publish_agent_event(event, run_id, session_id).await;