enact_runner/

session.rs

//! Session recorder and reader — one JSONL file per run under agents/<name>/sessions/ and optionally projects/<slug>/sessions/.
//!
//! This module provides:
//! - `SessionRecorder`: Write session events to JSONL files during execution
//! - `SessionReader`: Query and read session data from JSONL files
//! - `SessionQuery`: Filter and sort options for listing sessions
//! - `SessionSummary`: Summary info about a session (from start/finish events)

use anyhow::{Context, Result};
use chrono::Utc;
use serde::{Deserialize, Serialize};
use std::fs::{self, OpenOptions};
use std::io::{BufRead, BufReader, Write};
use std::path::PathBuf;

/// One JSONL event (start, step, or finish).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "event")]
pub enum SessionEvent {
    #[serde(rename = "start")]
    Start {
        session_id: String,
        agent: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        project: Option<String>,
        input: String,
        started_at: String,
    },
    #[serde(rename = "turn")]
    Turn {
        session_id: String,
        turn: u32,
        input: String,
        output: String,
        timestamp: String,
    },
    #[serde(rename = "tool_call")]
    ToolCall {
        session_id: String,
        tool_call_id: String,
        tool: String,
        input: serde_json::Value,
        timestamp: String,
    },
    #[serde(rename = "tool_call_result")]
    ToolCallResult {
        session_id: String,
        tool_call_id: String,
        tool: String,
        output: serde_json::Value,
        duration_ms: u64,
        timestamp: String,
    },
    #[serde(rename = "step")]
    Step {
        session_id: String,
        step: u32,
        tool: String,
        args: serde_json::Value,
        duration_ms: u64,
    },
    #[serde(rename = "finish")]
    Finish {
        session_id: String,
        outcome: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        output: Option<String>,
        iterations: usize,
        finished_at: String,
    },
}

// =============================================================================
// Session Reading Infrastructure
// =============================================================================

/// Session status (derived from finish event outcome)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SessionStatus {
    /// Session is currently running (no finish event yet)
    Running,
    /// Session completed successfully
    Completed,
    /// Session failed with an error
    Failed,
    /// Session was cancelled
    Cancelled,
}

impl SessionStatus {
    /// Parse status from outcome string in finish event
    pub fn from_outcome(outcome: &str) -> Self {
        match outcome.to_lowercase().as_str() {
            "completed" | "success" | "done" => SessionStatus::Completed,
            "failed" | "error" | "failure" => SessionStatus::Failed,
            "cancelled" | "canceled" => SessionStatus::Cancelled,
            _ => SessionStatus::Completed, // Default to completed for unknown outcomes
        }
    }
}

/// Sort order for session listing
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SortOrder {
    /// Most recent sessions first (default)
    #[default]
    NewestFirst,
    /// Oldest sessions first
    OldestFirst,
}

/// Query parameters for listing sessions
#[derive(Debug, Clone, Default)]
pub struct SessionQuery {
    /// Filter by agent name
    pub agent: Option<String>,
    /// Filter by project slug
    pub project: Option<String>,
    /// Filter by session status
    pub status: Option<SessionStatus>,
    /// Maximum number of results to return
    pub limit: Option<usize>,
    /// Number of results to skip (for pagination)
    pub offset: Option<usize>,
    /// Sort order
    pub sort: SortOrder,
}

impl SessionQuery {
    /// Create a new empty query (matches all sessions)
    pub fn new() -> Self {
        Self::default()
    }

    /// Filter by agent name
    pub fn with_agent(mut self, agent: impl Into<String>) -> Self {
        self.agent = Some(agent.into());
        self
    }

    /// Filter by project
    pub fn with_project(mut self, project: impl Into<String>) -> Self {
        self.project = Some(project.into());
        self
    }

    /// Filter by status
    pub fn with_status(mut self, status: SessionStatus) -> Self {
        self.status = Some(status);
        self
    }

    /// Set result limit
    pub fn with_limit(mut self, limit: usize) -> Self {
        self.limit = Some(limit);
        self
    }

    /// Set offset for pagination
    pub fn with_offset(mut self, offset: usize) -> Self {
        self.offset = Some(offset);
        self
    }

    /// Set sort order
    pub fn with_sort(mut self, sort: SortOrder) -> Self {
        self.sort = sort;
        self
    }
}

/// Summary information about a session
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionSummary {
    /// Unique session identifier
    pub session_id: String,
    /// Agent name that ran this session
    pub agent: String,
    /// Project this session belongs to (if any)
    pub project: Option<String>,
    /// Current session status
    pub status: SessionStatus,
    /// When the session started (ISO 8601)
    pub started_at: String,
    /// When the session finished (ISO 8601), None if still running
    pub finished_at: Option<String>,
    /// Number of conversation turns
    pub turn_count: u32,
    /// Number of tool calls made
    pub tool_call_count: u32,
    /// Initial input/prompt
    pub input: String,
    /// Final output (if completed)
    pub output: Option<String>,
    /// Session file path (relative to ENACT_HOME)
    pub file_path: String,
}

/// Detailed session information including all events
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionDetails {
    /// Summary information
    pub summary: SessionSummary,
    /// All events in the session
    pub events: Vec<SessionEvent>,
}

/// Reads session data from JSONL files
pub struct SessionReader {
    /// Directory containing agent sessions (e.g., ENACT_HOME/agents)
    agents_dir: PathBuf,
    /// Directory containing project sessions (e.g., ENACT_HOME/projects)
    projects_dir: Option<PathBuf>,
}

impl SessionReader {
    /// Create a new SessionReader
    ///
    /// # Arguments
    /// * `agents_dir` - Path to agents directory (contains <agent>/sessions/*.jsonl)
    /// * `projects_dir` - Optional path to projects directory
    pub fn new(agents_dir: PathBuf, projects_dir: Option<PathBuf>) -> Self {
        Self {
            agents_dir,
            projects_dir,
        }
    }

    /// List sessions matching the query
    pub fn list(&self, query: &SessionQuery) -> Result<Vec<SessionSummary>> {
        let mut summaries = Vec::new();

        // Collect sessions from agents directory
        if self.agents_dir.exists() {
            self.collect_sessions_from_agents(&mut summaries, query)?;
        }

        // Optionally collect from projects directory
        if let Some(ref projects_dir) = self.projects_dir {
            if projects_dir.exists() {
                self.collect_sessions_from_projects(&mut summaries, query)?;
            }
        }

        // Deduplicate by session_id (in case same session appears in both)
        summaries.sort_by(|a, b| a.session_id.cmp(&b.session_id));
        summaries.dedup_by(|a, b| a.session_id == b.session_id);

        // Sort by started_at timestamp
        match query.sort {
            SortOrder::NewestFirst => {
                summaries.sort_by(|a, b| b.started_at.cmp(&a.started_at));
            }
            SortOrder::OldestFirst => {
                summaries.sort_by(|a, b| a.started_at.cmp(&b.started_at));
            }
        }

        // Apply pagination
        let offset = query.offset.unwrap_or(0);
        let limit = query.limit.unwrap_or(usize::MAX);

        let result: Vec<SessionSummary> = summaries.into_iter().skip(offset).take(limit).collect();

        Ok(result)
    }

    /// Get detailed session information by session ID
    pub fn get(&self, session_id: &str) -> Result<Option<SessionDetails>> {
        // Search in agents directory
        if self.agents_dir.exists() {
            if let Some(details) = self.find_session_in_agents(session_id)? {
                return Ok(Some(details));
            }
        }

        // Search in projects directory
        if let Some(ref projects_dir) = self.projects_dir {
            if projects_dir.exists() {
                if let Some(details) = self.find_session_in_projects(session_id)? {
                    return Ok(Some(details));
                }
            }
        }

        Ok(None)
    }

    /// Collect sessions from agents/<name>/sessions/*.jsonl
    fn collect_sessions_from_agents(
        &self,
        summaries: &mut Vec<SessionSummary>,
        query: &SessionQuery,
    ) -> Result<()> {
        let entries = fs::read_dir(&self.agents_dir)
            .with_context(|| format!("Failed to read agents directory: {:?}", self.agents_dir))?;

        for entry in entries.filter_map(|e| e.ok()) {
            let agent_dir = entry.path();
            if !agent_dir.is_dir() {
                continue;
            }

            let agent_name = agent_dir
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("")
                .to_string();

            // Filter by agent if specified
            if let Some(ref filter_agent) = query.agent {
                if &agent_name != filter_agent {
                    continue;
                }
            }

            let sessions_dir = agent_dir.join("sessions");
            if sessions_dir.exists() {
                self.collect_sessions_from_dir(&sessions_dir, &agent_name, summaries, query)?;
            }
        }

        Ok(())
    }

    /// Collect sessions from projects/<slug>/sessions/*.jsonl
    fn collect_sessions_from_projects(
        &self,
        summaries: &mut Vec<SessionSummary>,
        query: &SessionQuery,
    ) -> Result<()> {
        let projects_dir = match &self.projects_dir {
            Some(d) => d,
            None => return Ok(()),
        };

        let entries = fs::read_dir(projects_dir)
            .with_context(|| format!("Failed to read projects directory: {:?}", projects_dir))?;

        for entry in entries.filter_map(|e| e.ok()) {
            let project_dir = entry.path();
            if !project_dir.is_dir() {
                continue;
            }

            let project_name = project_dir
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("")
                .to_string();

            // Filter by project if specified
            if let Some(ref filter_project) = query.project {
                if &project_name != filter_project {
                    continue;
                }
            }

            let sessions_dir = project_dir.join("sessions");
            if sessions_dir.exists() {
                self.collect_sessions_from_dir_with_project(
                    &sessions_dir,
                    &project_name,
                    summaries,
                    query,
                )?;
            }
        }

        Ok(())
    }

    /// Collect sessions from a specific sessions directory
    fn collect_sessions_from_dir(
        &self,
        sessions_dir: &PathBuf,
        agent_name: &str,
        summaries: &mut Vec<SessionSummary>,
        query: &SessionQuery,
    ) -> Result<()> {
        let entries = fs::read_dir(sessions_dir)
            .with_context(|| format!("Failed to read sessions directory: {:?}", sessions_dir))?;

        for entry in entries.filter_map(|e| e.ok()) {
            let path = entry.path();
            if path.extension().and_then(|s| s.to_str()) != Some("jsonl") {
                continue;
            }

            if let Ok(summary) = self.parse_session_file(&path, agent_name, None) {
                // Apply status filter
                if let Some(ref filter_status) = query.status {
                    if &summary.status != filter_status {
                        continue;
                    }
                }
                // Apply project filter
                if let Some(ref filter_project) = query.project {
                    if summary.project.as_ref() != Some(filter_project) {
                        continue;
                    }
                }
                summaries.push(summary);
            }
        }

        Ok(())
    }

    /// Collect sessions from a project sessions directory
    fn collect_sessions_from_dir_with_project(
        &self,
        sessions_dir: &PathBuf,
        project_name: &str,
        summaries: &mut Vec<SessionSummary>,
        query: &SessionQuery,
    ) -> Result<()> {
        let entries = fs::read_dir(sessions_dir)
            .with_context(|| format!("Failed to read sessions directory: {:?}", sessions_dir))?;

        for entry in entries.filter_map(|e| e.ok()) {
            let path = entry.path();
            if path.extension().and_then(|s| s.to_str()) != Some("jsonl") {
                continue;
            }

            if let Ok(summary) = self.parse_session_file(&path, "", Some(project_name)) {
                // Apply status filter
                if let Some(ref filter_status) = query.status {
                    if &summary.status != filter_status {
                        continue;
                    }
                }
                summaries.push(summary);
            }
        }

        Ok(())
    }

    /// Parse a session JSONL file and extract summary
    fn parse_session_file(
        &self,
        path: &PathBuf,
        default_agent: &str,
        default_project: Option<&str>,
    ) -> Result<SessionSummary> {
        let file = fs::File::open(path)
            .with_context(|| format!("Failed to open session file: {:?}", path))?;
        let reader = BufReader::new(file);

        let mut session_id = String::new();
        let mut agent = default_agent.to_string();
        let mut project = default_project.map(String::from);
        let mut status = SessionStatus::Running;
        let mut started_at = String::new();
        let mut finished_at: Option<String> = None;
        let mut turn_count = 0u32;
        let mut tool_call_count = 0u32;
        let mut input = String::new();
        let mut output: Option<String> = None;

        for line in reader.lines() {
            let line = line.with_context(|| format!("Failed to read line from: {:?}", path))?;
            if line.trim().is_empty() {
                continue;
            }

            if let Ok(event) = serde_json::from_str::<SessionEvent>(&line) {
                match event {
                    SessionEvent::Start {
                        session_id: sid,
                        agent: a,
                        project: p,
                        input: i,
                        started_at: s,
                    } => {
                        session_id = sid;
                        agent = a;
                        if p.is_some() {
                            project = p;
                        }
                        input = i;
                        started_at = s;
                    }
                    SessionEvent::Turn { .. } => {
                        turn_count += 1;
                    }
                    SessionEvent::ToolCall { .. } => {
                        tool_call_count += 1;
                    }
                    SessionEvent::ToolCallResult { .. } => {
                        // Already counted in ToolCall
                    }
                    SessionEvent::Step { .. } => {
                        // Legacy step events, count as tool calls
                        tool_call_count += 1;
                    }
                    SessionEvent::Finish {
                        outcome,
                        output: o,
                        finished_at: f,
                        ..
                    } => {
                        status = SessionStatus::from_outcome(&outcome);
                        output = o;
                        finished_at = Some(f);
                    }
                }
            }
        }

        // Build file_path relative to ENACT_HOME
        let file_path = path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("")
            .to_string();

        Ok(SessionSummary {
            session_id,
            agent,
            project,
            status,
            started_at,
            finished_at,
            turn_count,
            tool_call_count,
            input,
            output,
            file_path,
        })
    }

    /// Find a session by ID in the agents directory
    fn find_session_in_agents(&self, session_id: &str) -> Result<Option<SessionDetails>> {
        let entries = fs::read_dir(&self.agents_dir)
            .with_context(|| format!("Failed to read agents directory: {:?}", self.agents_dir))?;

        for entry in entries.filter_map(|e| e.ok()) {
            let agent_dir = entry.path();
            if !agent_dir.is_dir() {
                continue;
            }

            let sessions_dir = agent_dir.join("sessions");
            if !sessions_dir.exists() {
                continue;
            }

            if let Some(details) = self.find_session_in_dir(&sessions_dir, session_id)? {
                return Ok(Some(details));
            }
        }

        Ok(None)
    }

    /// Find a session by ID in the projects directory
    fn find_session_in_projects(&self, session_id: &str) -> Result<Option<SessionDetails>> {
        let projects_dir = match &self.projects_dir {
            Some(d) => d,
            None => return Ok(None),
        };

        let entries = fs::read_dir(projects_dir)
            .with_context(|| format!("Failed to read projects directory: {:?}", projects_dir))?;

        for entry in entries.filter_map(|e| e.ok()) {
            let project_dir = entry.path();
            if !project_dir.is_dir() {
                continue;
            }

            let sessions_dir = project_dir.join("sessions");
            if !sessions_dir.exists() {
                continue;
            }

            if let Some(details) = self.find_session_in_dir(&sessions_dir, session_id)? {
                return Ok(Some(details));
            }
        }

        Ok(None)
    }

    /// Find a session by ID in a specific sessions directory
    fn find_session_in_dir(
        &self,
        sessions_dir: &PathBuf,
        session_id: &str,
    ) -> Result<Option<SessionDetails>> {
        let entries = fs::read_dir(sessions_dir)
            .with_context(|| format!("Failed to read sessions directory: {:?}", sessions_dir))?;

        for entry in entries.filter_map(|e| e.ok()) {
            let path = entry.path();
            if path.extension().and_then(|s| s.to_str()) != Some("jsonl") {
                continue;
            }

            // Quick check: filename should contain the session_id
            let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
            if !filename.contains(session_id) {
                continue;
            }

            if let Ok(details) = self.parse_session_file_full(&path, session_id) {
                if details.summary.session_id == session_id {
                    return Ok(Some(details));
                }
            }
        }

        Ok(None)
    }

    /// Parse a session file and return full details
    fn parse_session_file_full(&self, path: &PathBuf, _session_id: &str) -> Result<SessionDetails> {
        let file = fs::File::open(path)
            .with_context(|| format!("Failed to open session file: {:?}", path))?;
        let reader = BufReader::new(file);

        let mut events = Vec::new();
        let mut session_id = String::new();
        let mut agent = String::new();
        let mut project: Option<String> = None;
        let mut status = SessionStatus::Running;
        let mut started_at = String::new();
        let mut finished_at: Option<String> = None;
        let mut turn_count = 0u32;
        let mut tool_call_count = 0u32;
        let mut input = String::new();
        let mut output: Option<String> = None;

        for line in reader.lines() {
            let line = line.with_context(|| format!("Failed to read line from: {:?}", path))?;
            if line.trim().is_empty() {
                continue;
            }

            if let Ok(event) = serde_json::from_str::<SessionEvent>(&line) {
                match &event {
                    SessionEvent::Start {
                        session_id: sid,
                        agent: a,
                        project: p,
                        input: i,
                        started_at: s,
                    } => {
                        session_id = sid.clone();
                        agent = a.clone();
                        project = p.clone();
                        input = i.clone();
                        started_at = s.clone();
                    }
                    SessionEvent::Turn { .. } => {
                        turn_count += 1;
                    }
                    SessionEvent::ToolCall { .. } => {
                        tool_call_count += 1;
                    }
                    SessionEvent::Step { .. } => {
                        tool_call_count += 1;
                    }
                    SessionEvent::Finish {
                        outcome,
                        output: o,
                        finished_at: f,
                        ..
                    } => {
                        status = SessionStatus::from_outcome(outcome);
                        output = o.clone();
                        finished_at = Some(f.clone());
                    }
                    _ => {}
                }
                events.push(event);
            }
        }

        let file_path = path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("")
            .to_string();

        Ok(SessionDetails {
            summary: SessionSummary {
                session_id,
                agent,
                project,
                status,
                started_at,
                finished_at,
                turn_count,
                tool_call_count,
                input,
                output,
                file_path,
            },
            events,
        })
    }
}

// =============================================================================
// SessionRecorder (existing implementation)
// =============================================================================

/// Writes one JSONL file per run. Call start() then zero or more step() then finish().
pub struct SessionRecorder {
    agent_sessions_dir: PathBuf,
    project_sessions_dir: Option<PathBuf>,
    agent: String,
    project: Option<String>,
    session_id: String,
    /// Set on start(); used for step/finish and for copy to project dir.
    filename: Option<String>,
}

impl SessionRecorder {
    /// Create a new recorder. Paths should be ENACT_HOME/agents/<name>/sessions and optionally ENACT_HOME/projects/<slug>/sessions.
    pub fn new(
        agent_sessions_dir: PathBuf,
        project_sessions_dir: Option<PathBuf>,
        agent: String,
        project: Option<String>,
        session_id: String,
    ) -> Self {
        Self {
            agent_sessions_dir,
            project_sessions_dir,
            agent,
            project,
            session_id,
            filename: None,
        }
    }

    /// Append one JSON line to path. Creates parent dirs and file if needed.
    fn append_line(path: &std::path::Path, line: &str) -> Result<()> {
        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent).context("Failed to create sessions directory")?;
        }
        let mut f = OpenOptions::new()
            .create(true)
            .append(true)
            .open(path)
            .context("Failed to open session file")?;
        writeln!(f, "{}", line).context("Failed to write session line")?;
        f.sync_all().context("Failed to sync session file")?;
        Ok(())
    }

    /// Record session start. Call once at the beginning of a run.
    pub fn start(&mut self, input: &str) -> Result<()> {
        let started_at = Utc::now().format("%Y-%m-%dT%H-%M-%SZ").to_string();
        let filename = format!("{}_{}.jsonl", started_at, self.session_id);
        self.filename = Some(filename.clone());

        let path = self.agent_sessions_dir.join(&filename);
        let event = SessionEvent::Start {
            session_id: self.session_id.clone(),
            agent: self.agent.clone(),
            project: self.project.clone(),
            input: input.to_string(),
            started_at: Utc::now().to_rfc3339(),
        };
        let line = serde_json::to_string(&event).context("Failed to serialize start event")?;
        Self::append_line(&path, &line)?;
        Ok(())
    }

    /// Record one conversation turn (user input + assistant output).
    pub fn turn(&self, turn: u32, input: &str, output: &str) -> Result<()> {
        let filename = self.filename.as_deref().ok_or_else(|| {
            anyhow::anyhow!("SessionRecorder: start() must be called before turn()")
        })?;
        let path = self.agent_sessions_dir.join(filename);
        let event = SessionEvent::Turn {
            session_id: self.session_id.clone(),
            turn,
            input: input.to_string(),
            output: output.to_string(),
            timestamp: Utc::now().to_rfc3339(),
        };
        let line = serde_json::to_string(&event).context("Failed to serialize turn event")?;
        Self::append_line(&path, &line)?;
        Ok(())
    }

    /// Record one tool step (legacy, for backwards compatibility).
    pub fn step(
        &self,
        step: u32,
        tool: &str,
        args: &serde_json::Value,
        duration_ms: u64,
    ) -> Result<()> {
        let filename = self.filename.as_deref().ok_or_else(|| {
            anyhow::anyhow!("SessionRecorder: start() must be called before step()")
        })?;
        let path = self.agent_sessions_dir.join(filename);
        let event = SessionEvent::Step {
            session_id: self.session_id.clone(),
            step,
            tool: tool.to_string(),
            args: args.clone(),
            duration_ms,
        };
        let line = serde_json::to_string(&event).context("Failed to serialize step event")?;
        Self::append_line(&path, &line)?;
        Ok(())
    }

    /// Record a tool call (input/arguments before execution).
    pub fn tool_call(
        &self,
        tool_call_id: &str,
        tool: &str,
        input: &serde_json::Value,
    ) -> Result<()> {
        let filename = self.filename.as_deref().ok_or_else(|| {
            anyhow::anyhow!("SessionRecorder: start() must be called before tool_call()")
        })?;
        let path = self.agent_sessions_dir.join(filename);
        let event = SessionEvent::ToolCall {
            session_id: self.session_id.clone(),
            tool_call_id: tool_call_id.to_string(),
            tool: tool.to_string(),
            input: input.clone(),
            timestamp: Utc::now().to_rfc3339(),
        };
        let line = serde_json::to_string(&event).context("Failed to serialize tool_call event")?;
        Self::append_line(&path, &line)?;
        Ok(())
    }

    /// Record a tool call result (output after execution).
    pub fn tool_call_result(
        &self,
        tool_call_id: &str,
        tool: &str,
        output: &serde_json::Value,
        duration_ms: u64,
    ) -> Result<()> {
        let filename = self.filename.as_deref().ok_or_else(|| {
            anyhow::anyhow!("SessionRecorder: start() must be called before tool_call_result()")
        })?;
        let path = self.agent_sessions_dir.join(filename);
        let event = SessionEvent::ToolCallResult {
            session_id: self.session_id.clone(),
            tool_call_id: tool_call_id.to_string(),
            tool: tool.to_string(),
            output: output.clone(),
            duration_ms,
            timestamp: Utc::now().to_rfc3339(),
        };
        let line =
            serde_json::to_string(&event).context("Failed to serialize tool_call_result event")?;
        Self::append_line(&path, &line)?;
        Ok(())
    }

    /// Record session finish. Copies the session file to project_sessions_dir if set.
    pub fn finish(&self, outcome: &str, output: Option<&str>, iterations: usize) -> Result<()> {
        let filename = self.filename.as_deref().ok_or_else(|| {
            anyhow::anyhow!("SessionRecorder: start() must be called before finish()")
        })?;
        let path = self.agent_sessions_dir.join(filename);
        let event = SessionEvent::Finish {
            session_id: self.session_id.clone(),
            outcome: outcome.to_string(),
            output: output.map(String::from),
            iterations,
            finished_at: Utc::now().to_rfc3339(),
        };
        let line = serde_json::to_string(&event).context("Failed to serialize finish event")?;
        Self::append_line(&path, &line)?;

        if let Some(ref project_dir) = self.project_sessions_dir {
            let dest = project_dir.join(filename);
            if path.exists() {
                std::fs::copy(&path, &dest).context("Failed to copy session file to project")?;
            }
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    #[test]
    fn session_event_start_serializes() {
        let e = SessionEvent::Start {
            session_id: "id1".to_string(),
            agent: "a".to_string(),
            project: None,
            input: "hi".to_string(),
            started_at: "2026-02-23T22:38:00Z".to_string(),
        };
        let j = serde_json::to_string(&e).unwrap();
        assert!(j.contains("\"event\":\"start\""));
        assert!(j.contains("\"session_id\":\"id1\""));
        assert!(j.contains("\"input\":\"hi\""));
    }

    #[test]
    fn session_event_turn_serializes() {
        let e = SessionEvent::Turn {
            session_id: "id1".to_string(),
            turn: 1,
            input: "Hello".to_string(),
            output: "Hi there!".to_string(),
            timestamp: "2026-02-23T22:38:00Z".to_string(),
        };
        let j = serde_json::to_string(&e).unwrap();
        assert!(j.contains("\"event\":\"turn\""));
        assert!(j.contains("\"turn\":1"));
        assert!(j.contains("\"input\":\"Hello\""));
        assert!(j.contains("\"output\":\"Hi there!\""));
    }

    #[test]
    fn session_event_step_serializes() {
        let e = SessionEvent::Step {
            session_id: "id1".to_string(),
            step: 1,
            tool: "search".to_string(),
            args: serde_json::json!({"query": "rust"}),
            duration_ms: 150,
        };
        let j = serde_json::to_string(&e).unwrap();
        assert!(j.contains("\"event\":\"step\""));
        assert!(j.contains("\"step\":1"));
        assert!(j.contains("\"tool\":\"search\""));
        assert!(j.contains("\"duration_ms\":150"));
    }

    #[test]
    fn session_event_tool_call_serializes() {
        let e = SessionEvent::ToolCall {
            session_id: "id1".to_string(),
            tool_call_id: "call-123".to_string(),
            tool: "shell".to_string(),
            input: serde_json::json!({"command": "ls -la"}),
            timestamp: "2026-02-25T12:00:00Z".to_string(),
        };
        let j = serde_json::to_string(&e).unwrap();
        assert!(j.contains("\"event\":\"tool_call\""));
        assert!(j.contains("\"tool_call_id\":\"call-123\""));
        assert!(j.contains("\"tool\":\"shell\""));
        assert!(j.contains("\"command\":\"ls -la\""));
    }

    #[test]
    fn session_event_tool_call_result_serializes() {
        let e = SessionEvent::ToolCallResult {
            session_id: "id1".to_string(),
            tool_call_id: "call-123".to_string(),
            tool: "shell".to_string(),
            output: serde_json::json!({"exit_code": 0, "stdout": "file.txt"}),
            duration_ms: 50,
            timestamp: "2026-02-25T12:00:01Z".to_string(),
        };
        let j = serde_json::to_string(&e).unwrap();
        assert!(j.contains("\"event\":\"tool_call_result\""));
        assert!(j.contains("\"tool_call_id\":\"call-123\""));
        assert!(j.contains("\"tool\":\"shell\""));
        assert!(j.contains("\"exit_code\":0"));
        assert!(j.contains("\"duration_ms\":50"));
    }

    #[test]
    fn session_event_finish_serializes() {
        let e = SessionEvent::Finish {
            session_id: "id1".to_string(),
            outcome: "completed".to_string(),
            output: Some("Done!".to_string()),
            iterations: 3,
            finished_at: "2026-02-23T22:40:00Z".to_string(),
        };
        let j = serde_json::to_string(&e).unwrap();
        assert!(j.contains("\"event\":\"finish\""));
        assert!(j.contains("\"outcome\":\"completed\""));
        assert!(j.contains("\"iterations\":3"));
    }

    #[test]
    fn session_recorder_start_creates_file() {
        let tmp = TempDir::new().unwrap();
        let sessions_dir = tmp.path().join("sessions");

        let mut recorder = SessionRecorder::new(
            sessions_dir.clone(),
            None,
            "test-agent".to_string(),
            None,
            "session-123".to_string(),
        );

        recorder.start("Hello world").unwrap();

        // Verify file was created
        let files: Vec<_> = std::fs::read_dir(&sessions_dir)
            .unwrap()
            .filter_map(|e| e.ok())
            .collect();
        assert_eq!(files.len(), 1);

        // Verify content
        let content = std::fs::read_to_string(files[0].path()).unwrap();
        assert!(content.contains("\"event\":\"start\""));
        assert!(content.contains("Hello world"));
    }

    #[test]
    fn session_recorder_turn_records_input_and_output() {
        let tmp = TempDir::new().unwrap();
        let sessions_dir = tmp.path().join("sessions");

        let mut recorder = SessionRecorder::new(
            sessions_dir.clone(),
            None,
            "test-agent".to_string(),
            None,
            "session-456".to_string(),
        );

        recorder.start("Session start").unwrap();
        recorder
            .turn(1, "User message", "Assistant response")
            .unwrap();

        // Read the session file
        let files: Vec<_> = std::fs::read_dir(&sessions_dir)
            .unwrap()
            .filter_map(|e| e.ok())
            .collect();
        let content = std::fs::read_to_string(files[0].path()).unwrap();
        let lines: Vec<&str> = content.lines().collect();

        assert_eq!(lines.len(), 2);
        assert!(lines[0].contains("\"event\":\"start\""));
        assert!(lines[1].contains("\"event\":\"turn\""));
        assert!(lines[1].contains("\"input\":\"User message\""));
        assert!(lines[1].contains("\"output\":\"Assistant response\""));
    }

    #[test]
    fn session_recorder_step_records_tool_calls() {
        let tmp = TempDir::new().unwrap();
        let sessions_dir = tmp.path().join("sessions");

        let mut recorder = SessionRecorder::new(
            sessions_dir.clone(),
            None,
            "test-agent".to_string(),
            None,
            "session-789".to_string(),
        );

        recorder.start("Session start").unwrap();
        recorder
            .step(
                1,
                "search",
                &serde_json::json!({"query": "rust async"}),
                250,
            )
            .unwrap();
        recorder
            .step(
                2,
                "read_file",
                &serde_json::json!({"path": "/tmp/test.rs"}),
                50,
            )
            .unwrap();

        // Read the session file
        let files: Vec<_> = std::fs::read_dir(&sessions_dir)
            .unwrap()
            .filter_map(|e| e.ok())
            .collect();
        let content = std::fs::read_to_string(files[0].path()).unwrap();
        let lines: Vec<&str> = content.lines().collect();

        assert_eq!(lines.len(), 3);
        assert!(lines[1].contains("\"tool\":\"search\""));
        assert!(lines[1].contains("\"duration_ms\":250"));
        assert!(lines[2].contains("\"tool\":\"read_file\""));
    }

    #[test]
    fn session_recorder_full_flow() {
        let tmp = TempDir::new().unwrap();
        let sessions_dir = tmp.path().join("sessions");

        let mut recorder = SessionRecorder::new(
            sessions_dir.clone(),
            None,
            "test-agent".to_string(),
            None,
            "session-full".to_string(),
        );

        // Full session flow: start -> step -> turn -> step -> turn -> finish
        recorder.start("Conversation started").unwrap();
        recorder
            .step(1, "search", &serde_json::json!({"q": "test"}), 100)
            .unwrap();
        recorder
            .turn(1, "Find info about X", "Here's what I found...")
            .unwrap();
        recorder
            .step(2, "read_file", &serde_json::json!({"path": "x.rs"}), 50)
            .unwrap();
        recorder
            .turn(2, "What does the file say?", "The file contains...")
            .unwrap();
        recorder
            .finish("completed", Some("Session done"), 2)
            .unwrap();

        // Read and verify
        let files: Vec<_> = std::fs::read_dir(&sessions_dir)
            .unwrap()
            .filter_map(|e| e.ok())
            .collect();
        let content = std::fs::read_to_string(files[0].path()).unwrap();
        let lines: Vec<&str> = content.lines().collect();

        assert_eq!(lines.len(), 6);
        assert!(lines[0].contains("\"event\":\"start\""));
        assert!(lines[1].contains("\"event\":\"step\""));
        assert!(lines[2].contains("\"event\":\"turn\""));
        assert!(lines[3].contains("\"event\":\"step\""));
        assert!(lines[4].contains("\"event\":\"turn\""));
        assert!(lines[5].contains("\"event\":\"finish\""));
    }

    #[test]
    fn session_recorder_turn_without_start_fails() {
        let tmp = TempDir::new().unwrap();
        let sessions_dir = tmp.path().join("sessions");

        let recorder = SessionRecorder::new(
            sessions_dir,
            None,
            "test-agent".to_string(),
            None,
            "session-nostart".to_string(),
        );

        let result = recorder.turn(1, "input", "output");
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("start() must be called"));
    }

    #[test]
    fn session_recorder_step_without_start_fails() {
        let tmp = TempDir::new().unwrap();
        let sessions_dir = tmp.path().join("sessions");

        let recorder = SessionRecorder::new(
            sessions_dir,
            None,
            "test-agent".to_string(),
            None,
            "session-nostart".to_string(),
        );

        let result = recorder.step(1, "tool", &serde_json::json!({}), 100);
        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .to_string()
            .contains("start() must be called"));
    }

    // =========================================================================
    // SessionReader Tests
    // =========================================================================

    #[test]
    fn session_status_from_outcome() {
        assert_eq!(
            SessionStatus::from_outcome("completed"),
            SessionStatus::Completed
        );
        assert_eq!(
            SessionStatus::from_outcome("COMPLETED"),
            SessionStatus::Completed
        );
        assert_eq!(
            SessionStatus::from_outcome("success"),
            SessionStatus::Completed
        );
        assert_eq!(SessionStatus::from_outcome("failed"), SessionStatus::Failed);
        assert_eq!(SessionStatus::from_outcome("error"), SessionStatus::Failed);
        assert_eq!(
            SessionStatus::from_outcome("cancelled"),
            SessionStatus::Cancelled
        );
        assert_eq!(
            SessionStatus::from_outcome("canceled"),
            SessionStatus::Cancelled
        );
        // Unknown defaults to Completed
        assert_eq!(
            SessionStatus::from_outcome("unknown"),
            SessionStatus::Completed
        );
    }

    #[test]
    fn session_query_builder() {
        let query = SessionQuery::new()
            .with_agent("test-agent")
            .with_project("test-project")
            .with_status(SessionStatus::Completed)
            .with_limit(10)
            .with_offset(5)
            .with_sort(SortOrder::OldestFirst);

        assert_eq!(query.agent, Some("test-agent".to_string()));
        assert_eq!(query.project, Some("test-project".to_string()));
        assert_eq!(query.status, Some(SessionStatus::Completed));
        assert_eq!(query.limit, Some(10));
        assert_eq!(query.offset, Some(5));
        assert_eq!(query.sort, SortOrder::OldestFirst);
    }

    #[test]
    fn session_reader_empty_directory() {
        let tmp = TempDir::new().unwrap();
        let agents_dir = tmp.path().join("agents");
        std::fs::create_dir_all(&agents_dir).unwrap();

        let reader = SessionReader::new(agents_dir, None);
        let sessions = reader.list(&SessionQuery::new()).unwrap();

        assert!(sessions.is_empty());
    }

    #[test]
    fn session_reader_lists_sessions() {
        let tmp = TempDir::new().unwrap();
        let agents_dir = tmp.path().join("agents");
        let sessions_dir = agents_dir.join("test-agent").join("sessions");
        std::fs::create_dir_all(&sessions_dir).unwrap();

        // Create a session file
        let mut recorder = SessionRecorder::new(
            sessions_dir.clone(),
            None,
            "test-agent".to_string(),
            None,
            "session-list-test".to_string(),
        );
        recorder.start("Hello world").unwrap();
        recorder.turn(1, "Hello", "Hi there!").unwrap();
        recorder.finish("completed", Some("Done"), 1).unwrap();

        // Read sessions
        let reader = SessionReader::new(agents_dir, None);
        let sessions = reader.list(&SessionQuery::new()).unwrap();

        assert_eq!(sessions.len(), 1);
        assert_eq!(sessions[0].session_id, "session-list-test");
        assert_eq!(sessions[0].agent, "test-agent");
        assert_eq!(sessions[0].status, SessionStatus::Completed);
        assert_eq!(sessions[0].turn_count, 1);
    }

    #[test]
    fn session_reader_filters_by_agent() {
        let tmp = TempDir::new().unwrap();
        let agents_dir = tmp.path().join("agents");

        // Create sessions for two agents
        for agent in ["agent1", "agent2"] {
            let sessions_dir = agents_dir.join(agent).join("sessions");
            std::fs::create_dir_all(&sessions_dir).unwrap();

            let mut recorder = SessionRecorder::new(
                sessions_dir,
                None,
                agent.to_string(),
                None,
                format!("session-{}", agent),
            );
            recorder.start("Test").unwrap();
            recorder.finish("completed", None, 0).unwrap();
        }

        let reader = SessionReader::new(agents_dir, None);

        // Filter by agent1
        let sessions = reader
            .list(&SessionQuery::new().with_agent("agent1"))
            .unwrap();
        assert_eq!(sessions.len(), 1);
        assert_eq!(sessions[0].agent, "agent1");

        // All sessions
        let all_sessions = reader.list(&SessionQuery::new()).unwrap();
        assert_eq!(all_sessions.len(), 2);
    }

    #[test]
    fn session_reader_filters_by_status() {
        let tmp = TempDir::new().unwrap();
        let agents_dir = tmp.path().join("agents");
        let sessions_dir = agents_dir.join("test-agent").join("sessions");
        std::fs::create_dir_all(&sessions_dir).unwrap();

        // Create completed session
        let mut recorder = SessionRecorder::new(
            sessions_dir.clone(),
            None,
            "test-agent".to_string(),
            None,
            "completed-session".to_string(),
        );
        recorder.start("Test 1").unwrap();
        recorder.finish("completed", None, 0).unwrap();

        // Create failed session
        let mut recorder = SessionRecorder::new(
            sessions_dir.clone(),
            None,
            "test-agent".to_string(),
            None,
            "failed-session".to_string(),
        );
        recorder.start("Test 2").unwrap();
        recorder.finish("failed", None, 0).unwrap();

        let reader = SessionReader::new(agents_dir, None);

        // Filter by completed
        let completed = reader
            .list(&SessionQuery::new().with_status(SessionStatus::Completed))
            .unwrap();
        assert_eq!(completed.len(), 1);
        assert_eq!(completed[0].status, SessionStatus::Completed);

        // Filter by failed
        let failed = reader
            .list(&SessionQuery::new().with_status(SessionStatus::Failed))
            .unwrap();
        assert_eq!(failed.len(), 1);
        assert_eq!(failed[0].status, SessionStatus::Failed);
    }

    #[test]
    fn session_reader_get_session_details() {
        let tmp = TempDir::new().unwrap();
        let agents_dir = tmp.path().join("agents");
        let sessions_dir = agents_dir.join("test-agent").join("sessions");
        std::fs::create_dir_all(&sessions_dir).unwrap();

        let mut recorder = SessionRecorder::new(
            sessions_dir,
            None,
            "test-agent".to_string(),
            None,
            "detail-test".to_string(),
        );
        recorder.start("Initial prompt").unwrap();
        recorder.turn(1, "User input", "Assistant output").unwrap();
        recorder
            .step(1, "shell", &serde_json::json!({"cmd": "ls"}), 50)
            .unwrap();
        recorder
            .finish("completed", Some("Final output"), 1)
            .unwrap();

        let reader = SessionReader::new(agents_dir, None);
        let details = reader.get("detail-test").unwrap();

        assert!(details.is_some());
        let details = details.unwrap();
        assert_eq!(details.summary.session_id, "detail-test");
        assert_eq!(details.summary.input, "Initial prompt");
        assert_eq!(details.summary.output, Some("Final output".to_string()));
        assert_eq!(details.events.len(), 4); // start, turn, step, finish
    }

    #[test]
    fn session_reader_pagination() {
        let tmp = TempDir::new().unwrap();
        let agents_dir = tmp.path().join("agents");
        let sessions_dir = agents_dir.join("test-agent").join("sessions");
        std::fs::create_dir_all(&sessions_dir).unwrap();

        // Create 5 sessions
        for i in 0..5 {
            let mut recorder = SessionRecorder::new(
                sessions_dir.clone(),
                None,
                "test-agent".to_string(),
                None,
                format!("session-{}", i),
            );
            recorder.start(&format!("Test {}", i)).unwrap();
            recorder.finish("completed", None, 0).unwrap();
        }

        let reader = SessionReader::new(agents_dir, None);

        // First page
        let page1 = reader
            .list(&SessionQuery::new().with_limit(2).with_offset(0))
            .unwrap();
        assert_eq!(page1.len(), 2);

        // Second page
        let page2 = reader
            .list(&SessionQuery::new().with_limit(2).with_offset(2))
            .unwrap();
        assert_eq!(page2.len(), 2);

        // Last page
        let page3 = reader
            .list(&SessionQuery::new().with_limit(2).with_offset(4))
            .unwrap();
        assert_eq!(page3.len(), 1);
    }

    #[test]
    fn session_summary_serialization() {
        let summary = SessionSummary {
            session_id: "test-123".to_string(),
            agent: "test-agent".to_string(),
            project: Some("test-project".to_string()),
            status: SessionStatus::Completed,
            started_at: "2026-02-26T12:00:00Z".to_string(),
            finished_at: Some("2026-02-26T12:05:00Z".to_string()),
            turn_count: 5,
            tool_call_count: 3,
            input: "Hello".to_string(),
            output: Some("Goodbye".to_string()),
            file_path: "2026-02-26T12-00-00Z_test-123.jsonl".to_string(),
        };

        let json = serde_json::to_string(&summary).unwrap();
        let parsed: SessionSummary = serde_json::from_str(&json).unwrap();

        assert_eq!(parsed.session_id, "test-123");
        assert_eq!(parsed.status, SessionStatus::Completed);
        assert_eq!(parsed.turn_count, 5);
    }
}