agentty 0.10.6

//! Session-scoped persistence adapters and query helpers.

use async_trait::async_trait;
use sqlx::SqlitePool;

use super::review::SessionReviewRequestRow;
use crate::domain::agent::ReasoningLevel;
use crate::domain::session::{SessionFollowUpTask, SessionId, SessionStats};
use crate::infra::agent;
use crate::infra::db::DbError;

/// Transactional turn-metadata payload persisted after one completed agent
/// turn.
///
/// Owns its fields so the persistence trait method stays lifetime-free. A
/// borrowed variant (`SessionTurnMetadata<'a>`) forced the persist method to
/// carry a generic lifetime, which `mockall::automock` drops in the generated
/// mock and newer `clippy` then rejects via `extra_unused_lifetimes`. Owning
/// the data is allocation-cheap on this once-per-turn path and keeps the trait
/// signature stable across toolchains.
pub struct SessionTurnMetadata {
    /// Session-scoped instruction bootstrap marker for app-server providers.
    pub(crate) instruction_conversation_id: Option<String>,
    /// Model identifier used for per-model usage aggregation.
    pub(crate) model: String,
    /// Persisted provider-native conversation identifier for future resumes.
    pub(crate) provider_conversation_id: Option<String>,
    /// Serialized clarification-question payload stored on the session row.
    pub(crate) questions_json: String,
    /// Serialized structured summary payload stored on the session row.
    pub(crate) summary: String,
    /// Token-usage delta attributed to the completed turn.
    pub(crate) token_usage_delta: SessionStats,
}

/// Row returned when loading a session from the `session` table.
///
/// Includes optional normalized forge review-request linkage metadata loaded
/// through the `session_review_request` table when the session has been
/// published for remote review.
pub struct SessionRow {
    pub added_lines: i64,
    pub base_branch: String,
    pub created_at: i64,
    pub deleted_lines: i64,
    pub id: String,
    pub in_progress_started_at: Option<i64>,
    pub in_progress_total_seconds: i64,
    pub input_tokens: i64,
    pub is_draft: bool,
    pub model: String,
    pub output: String,
    pub output_tokens: i64,
    pub parent_session_id: Option<String>,
    pub project_id: Option<i64>,
    pub prompt: String,
    pub reasoning_level_override: Option<String>,
    pub published_upstream_ref: Option<String>,
    pub questions: Option<String>,
    pub review_request: Option<SessionReviewRequestRow>,
    pub size: String,
    pub status: String,
    pub summary: Option<String>,
    pub title: Option<String>,
    pub updated_at: i64,
}

/// Lightweight row returned when loading session-list metadata.
///
/// Omits transcript-scale fields (`output`, `prompt`, `questions`, and
/// `summary`) so list refreshes scale with visible metadata instead of the
/// cumulative size of every saved conversation.
pub struct SessionListRow {
    /// Persisted added-line count from the latest diff stats refresh.
    pub added_lines: i64,
    /// Base branch used to create the session worktree.
    pub base_branch: String,
    /// Session creation timestamp in Unix seconds.
    pub created_at: i64,
    /// Persisted deleted-line count from the latest diff stats refresh.
    pub deleted_lines: i64,
    /// Stable session identifier.
    pub id: String,
    /// Open active-work interval start timestamp, if any.
    pub in_progress_started_at: Option<i64>,
    /// Completed active-work duration in whole seconds.
    pub in_progress_total_seconds: i64,
    /// Total input tokens accumulated for the session.
    pub input_tokens: i64,
    /// Whether the session is still an explicit draft.
    pub is_draft: bool,
    /// Persisted agent model identifier.
    pub model: String,
    /// Total output tokens accumulated for the session.
    pub output_tokens: i64,
    /// Parent session id when this row is a one-level stacked draft.
    pub parent_session_id: Option<String>,
    /// Owning project identifier, when present.
    pub project_id: Option<i64>,
    /// Persisted session-specific reasoning override, when present.
    pub reasoning_level_override: Option<String>,
    /// Published upstream branch reference, when present.
    pub published_upstream_ref: Option<String>,
    /// Joined forge review-request metadata, when present and complete.
    pub review_request: Option<SessionReviewRequestRow>,
    /// Persisted size bucket string.
    pub size: String,
    /// Persisted lifecycle status string.
    pub status: String,
    /// Optional display title.
    pub title: Option<String>,
    /// Last update timestamp in Unix seconds.
    pub updated_at: i64,
}

/// Transcript-detail row loaded lazily for the session being viewed.
#[derive(sqlx::FromRow)]
pub struct SessionDetailRow {
    /// Captured provider transcript text.
    pub output: String,
    /// Initial or staged prompt text.
    pub prompt: String,
    /// Serialized clarification-question payload, when present.
    pub questions: Option<String>,
    /// Persisted structured summary text, when present.
    pub summary: Option<String>,
}

/// Row returned when loading one persisted `session_follow_up_task`.
#[derive(Clone, Debug, Eq, PartialEq, sqlx::FromRow)]
pub struct SessionFollowUpTaskRow {
    /// Stable row identifier generated by `SQLite`.
    pub id: i64,
    /// Session id launched from this follow-up task, when one exists.
    pub launched_session_id: Option<String>,
    /// Display order for the task within its owning session.
    pub position: i64,
    /// Owning session identifier.
    pub session_id: String,
    /// Persisted follow-up task text shown to the user.
    pub text: String,
}

/// Row returned when hydrating persisted focused-review cache entries.
#[derive(Clone, Debug, Eq, PartialEq, sqlx::FromRow)]
pub struct SessionFocusedReviewRow {
    /// Diff-content hash captured when the focused review was generated.
    pub(crate) diff_hash: String,
    /// Stable session identifier.
    pub(crate) session_id: String,
    /// Generated focused-review markdown text.
    pub(crate) text: String,
}

impl SessionFollowUpTaskRow {
    /// Converts one follow-up-task row into the domain snapshot used by the
    /// UI.
    pub(crate) fn into_session_follow_up_task(self) -> SessionFollowUpTask {
        SessionFollowUpTask {
            id: self.id,
            launched_session_id: self.launched_session_id.map(SessionId::from),
            position: usize::try_from(self.position).unwrap_or(usize::MAX),
            text: self.text,
        }
    }
}
/// Session-focused persistence boundary used by app orchestration and tests.
#[async_trait]
pub trait SessionRepository: Send + Sync {
    /// Appends text to the saved output for a session row.
    async fn append_session_output(&self, id: &str, chunk: &str) -> Result<(), DbError>;

    /// Sets `project_id` for sessions that do not yet reference a project.
    async fn backfill_session_project(&self, project_id: i64) -> Result<(), DbError>;

    /// Deletes a session row by identifier.
    async fn delete_session(&self, id: &str) -> Result<(), DbError>;

    /// Returns the persisted base branch for a session, when present.
    async fn get_session_base_branch(&self, id: &str) -> Result<Option<String>, DbError>;

    /// Returns the persisted app-server instruction bootstrap marker for a
    /// session, when present.
    async fn get_session_instruction_conversation_id(
        &self,
        id: &str,
    ) -> Result<Option<String>, DbError>;

    /// Returns the provider conversation identifier for a session, when
    /// present.
    async fn get_session_provider_conversation_id(
        &self,
        id: &str,
    ) -> Result<Option<String>, DbError>;

    /// Inserts a newly created draft-session row.
    async fn insert_draft_session(
        &self,
        id: &str,
        model: &str,
        base_branch: &str,
        status: &str,
        project_id: i64,
    ) -> Result<(), DbError>;

    /// Inserts a newly created stacked draft-session row.
    async fn insert_stacked_draft_session(
        &self,
        id: &str,
        model: &str,
        base_branch: &str,
        status: &str,
        parent_session_id: &str,
        project_id: i64,
    ) -> Result<(), DbError>;

    /// Inserts a newly created session row.
    async fn insert_session(
        &self,
        id: &str,
        model: &str,
        base_branch: &str,
        status: &str,
        project_id: i64,
    ) -> Result<(), DbError>;

    #[cfg(test)]
    /// Loads all sessions ordered by most recent update.
    async fn load_sessions(&self) -> Result<Vec<SessionRow>, DbError>;

    /// Loads lightweight session-list metadata ordered by most recent update
    /// for one project.
    async fn load_sessions_for_project(
        &self,
        project_id: i64,
    ) -> Result<Vec<SessionListRow>, DbError>;

    /// Loads transcript-scale detail for one session when it becomes active.
    async fn load_session_detail(
        &self,
        session_id: &str,
    ) -> Result<Option<SessionDetailRow>, DbError>;

    /// Loads all persisted session follow-up-task rows in stable display
    /// order.
    async fn load_session_follow_up_tasks(&self) -> Result<Vec<SessionFollowUpTaskRow>, DbError>;

    /// Loads persisted focused-review cache rows for one project.
    async fn load_session_focused_reviews_for_project(
        &self,
        project_id: i64,
    ) -> Result<Vec<SessionFocusedReviewRow>, DbError>;

    /// Loads lightweight session metadata used for cheap change detection.
    async fn load_sessions_metadata(&self) -> Result<(i64, i64), DbError>;

    /// Loads the project identifier associated with one session.
    async fn load_session_project_id(&self, session_id: &str) -> Result<Option<i64>, DbError>;

    /// Returns the persisted upstream reference for a published session
    /// branch, when present.
    async fn load_session_published_upstream_ref(
        &self,
        id: &str,
    ) -> Result<Option<String>, DbError>;

    /// Loads the persisted merged commit hash for one session, when present.
    async fn load_session_merged_commit_hash(
        &self,
        session_id: &str,
    ) -> Result<Option<String>, DbError>;

    /// Clears parent links for draft children after their parent session
    /// merges into its base branch.
    async fn restack_child_sessions_after_parent_merge(
        &self,
        parent_session_id: &str,
        base_branch: &str,
    ) -> Result<(), DbError>;

    /// Loads the persisted session-specific reasoning override, when present.
    async fn load_session_reasoning_level_override(
        &self,
        session_id: &str,
    ) -> Result<Option<ReasoningLevel>, DbError>;

    /// Loads the persisted summary text associated with one session.
    async fn load_session_summary(&self, session_id: &str) -> Result<Option<String>, DbError>;

    /// Returns `(created_at, updated_at)` timestamps for a session.
    async fn load_session_timestamps(
        &self,
        session_id: &str,
    ) -> Result<Option<(i64, i64)>, DbError>;

    /// Persists all canonical turn metadata for one completed agent turn in a
    /// single transaction.
    async fn persist_session_turn_metadata(
        &self,
        session_id: &str,
        turn_metadata: &SessionTurnMetadata,
    ) -> Result<(), DbError>;

    #[cfg(test)]
    /// Replaces the full output for a session row.
    async fn replace_session_output(&self, id: &str, output: &str) -> Result<(), DbError>;

    /// Replaces the persisted follow-up task list for one session inside one
    /// transaction so task deletion and reinsertion commit atomically.
    async fn replace_session_follow_up_tasks(
        &self,
        session_id: &str,
        follow_up_tasks: &[String],
    ) -> Result<(), DbError>;

    /// Updates persisted diff-derived size and line-count fields for a
    /// session row.
    async fn update_session_diff_stats(
        &self,
        added_lines: u64,
        deleted_lines: u64,
        id: &str,
        size: &str,
    ) -> Result<(), DbError>;

    /// Updates the launched sibling-session link for one persisted follow-up
    /// task.
    async fn update_session_follow_up_task_launched_session_id(
        &self,
        session_id: &str,
        position: usize,
        launched_session_id: Option<String>,
    ) -> Result<(), DbError>;

    /// Updates the persisted app-server instruction bootstrap marker for a
    /// session.
    async fn update_session_instruction_conversation_id(
        &self,
        id: &str,
        provider_conversation_id: Option<String>,
    ) -> Result<(), DbError>;

    /// Updates the persisted model for a session.
    async fn update_session_model(&self, id: &str, model: &str) -> Result<(), DbError>;

    /// Updates the persisted merged commit hash for a session row.
    async fn update_session_merged_commit_hash(
        &self,
        id: &str,
        merged_commit_hash: Option<String>,
    ) -> Result<(), DbError>;

    /// Updates the saved prompt for a session row.
    async fn update_session_prompt(&self, id: &str, prompt: &str) -> Result<(), DbError>;

    /// Updates the persisted provider conversation identifier for a session.
    async fn update_session_provider_conversation_id(
        &self,
        id: &str,
        provider_conversation_id: Option<String>,
    ) -> Result<(), DbError>;

    /// Updates the model clarification questions for a session row.
    async fn update_session_questions(&self, id: &str, questions: &str) -> Result<(), DbError>;

    /// Updates the persisted session-specific reasoning override.
    async fn update_session_reasoning_level(
        &self,
        id: &str,
        reasoning_level: Option<String>,
    ) -> Result<(), DbError>;

    /// Updates the persisted upstream reference for a published session
    /// branch.
    async fn update_session_published_upstream_ref(
        &self,
        id: &str,
        published_upstream_ref: Option<String>,
    ) -> Result<(), DbError>;

    /// Accumulates token statistics for a session.
    async fn update_session_stats(&self, id: &str, stats: &SessionStats) -> Result<(), DbError>;

    /// Updates the status for a session row and opens or closes the persisted
    /// cumulative active-work interval when crossing the `InProgress`
    /// boundary.
    async fn update_session_status_with_timing_at(
        &self,
        id: &str,
        status: &str,
        timestamp_seconds: i64,
    ) -> Result<(), DbError>;

    /// Updates the persisted session summary text for a session row.
    async fn update_session_summary(&self, id: &str, summary: &str) -> Result<(), DbError>;

    /// Updates or clears the persisted focused-review cache for a session.
    async fn update_session_focused_review(
        &self,
        id: &str,
        diff_hash: Option<String>,
        text: Option<String>,
    ) -> Result<(), DbError>;

    /// Updates the display title for a session row.
    async fn update_session_title(&self, id: &str, title: &str) -> Result<(), DbError>;

    /// Updates the display title for a session row only when the persisted
    /// prompt still matches the prompt snapshot used to generate that title.
    async fn update_session_title_for_prompt(
        &self,
        id: &str,
        expected_prompt: &str,
        title: &str,
    ) -> Result<bool, DbError>;

    /// Overrides the `created_at` timestamp for one session row.
    #[cfg(test)]
    async fn update_session_created_at(&self, id: &str, created_at: i64) -> Result<(), DbError>;

    #[cfg(test)]
    /// Overrides the `updated_at` timestamp for one session row.
    async fn update_session_updated_at(&self, id: &str, updated_at: i64) -> Result<(), DbError>;
}

/// `SQLite` implementation of [`SessionRepository`].
#[derive(Clone)]
pub(crate) struct SqliteSessionRepository(SqlitePool);

impl SqliteSessionRepository {
    /// Creates a session repository backed by the provided pool.
    pub(crate) fn new(pool: SqlitePool) -> Self {
        Self(pool)
    }
}

/// Row returned when loading a required string scalar value.
struct RequiredStringValueRow {
    value: String,
}

/// Row returned when loading session count and latest-update metadata.
struct SessionMetadataRow {
    max_updated_at: i64,
    session_count: i64,
}

/// Row returned when loading an optional `i64` scalar value.
struct OptionalI64ValueRow {
    value: Option<i64>,
}

/// Row returned when loading the persisted instruction bootstrap marker for
/// one session.
#[derive(sqlx::FromRow)]
struct SessionInstructionStateRow {
    app_server_instruction_provider_conversation_id: Option<String>,
}

impl SessionInstructionStateRow {
    /// Converts the optional stored provider conversation id into one
    /// normalized bootstrap conversation id when present and non-empty.
    fn into_instruction_conversation_id(self) -> Option<String> {
        agent::normalize_instruction_conversation_id(
            self.app_server_instruction_provider_conversation_id
                .as_deref(),
        )
    }
}

/// Row returned when loading both persisted timestamps for one session.
struct SessionTimestampsRow {
    created_at: i64,
    updated_at: i64,
}

/// Row returned when loading one `session` plus aliased
/// `session_review_request` join columns.
#[cfg(test)]
pub(crate) struct SessionJoinRow {
    added_lines: i64,
    base_branch: String,
    created_at: i64,
    deleted_lines: i64,
    id: String,
    in_progress_started_at: Option<i64>,
    in_progress_total_seconds: i64,
    input_tokens: i64,
    is_draft: bool,
    model: String,
    output: String,
    output_tokens: i64,
    parent_session_id: Option<String>,
    project_id: Option<i64>,
    prompt: String,
    reasoning_level_override: Option<String>,
    published_upstream_ref: Option<String>,
    questions: Option<String>,
    review_request_display_id: Option<String>,
    review_request_forge_kind: Option<String>,
    pub(crate) review_request_last_refreshed_at: Option<i64>,
    review_request_source_branch: Option<String>,
    review_request_state: Option<String>,
    review_request_status_summary: Option<String>,
    review_request_target_branch: Option<String>,
    review_request_title: Option<String>,
    review_request_web_url: Option<String>,
    size: String,
    status: String,
    summary: Option<String>,
    title: Option<String>,
    updated_at: i64,
}

#[cfg(test)]
impl SessionJoinRow {
    /// Converts the macro-mapped join row into the public `SessionRow` model.
    pub(crate) fn into_session_row(self) -> SessionRow {
        let Self {
            added_lines,
            base_branch,
            created_at,
            deleted_lines,
            id,
            in_progress_started_at,
            in_progress_total_seconds,
            input_tokens,
            is_draft,
            model,
            output,
            output_tokens,
            parent_session_id,
            project_id,
            prompt,
            reasoning_level_override,
            published_upstream_ref,
            questions,
            review_request_display_id,
            review_request_forge_kind,
            review_request_last_refreshed_at,
            review_request_source_branch,
            review_request_state,
            review_request_status_summary,
            review_request_target_branch,
            review_request_title,
            review_request_web_url,
            size,
            status,
            summary,
            title,
            updated_at,
        } = self;

        let review_request = SessionReviewRequestJoinRow {
            display_id: review_request_display_id,
            forge_kind: review_request_forge_kind,
            last_refreshed_at: review_request_last_refreshed_at,
            source_branch: review_request_source_branch,
            state: review_request_state,
            status_summary: review_request_status_summary,
            target_branch: review_request_target_branch,
            title: review_request_title,
            web_url: review_request_web_url,
        }
        .into_review_request_row();

        SessionRow {
            added_lines,
            base_branch,
            created_at,
            deleted_lines,
            id,
            in_progress_started_at,
            in_progress_total_seconds,
            input_tokens,
            is_draft,
            model,
            output,
            output_tokens,
            parent_session_id,
            project_id,
            prompt,
            reasoning_level_override,
            published_upstream_ref,
            questions,
            review_request,
            size,
            status,
            summary,
            title,
            updated_at,
        }
    }

    #[cfg(test)]
    /// Builds a deterministic joined-session row fixture for repository tests.
    pub(crate) fn fixture_for_test() -> Self {
        Self {
            added_lines: 14,
            base_branch: "main".to_string(),
            created_at: 100,
            deleted_lines: 6,
            id: "session-a".to_string(),
            in_progress_started_at: None,
            in_progress_total_seconds: 0,
            input_tokens: 11,
            is_draft: false,
            model: "gpt-5.5".to_string(),
            output: "Saved output".to_string(),
            output_tokens: 29,
            parent_session_id: Some("parent-session".to_string()),
            project_id: Some(7),
            prompt: "Implement feature".to_string(),
            reasoning_level_override: None,
            published_upstream_ref: Some("origin/session-a".to_string()),
            questions: Some("Question text".to_string()),
            review_request_display_id: Some("#42".to_string()),
            review_request_forge_kind: Some("GitHub".to_string()),
            review_request_last_refreshed_at: Some(456),
            review_request_source_branch: Some("feature/forge".to_string()),
            review_request_state: Some("Open".to_string()),
            review_request_status_summary: Some("2 approvals, checks passing".to_string()),
            review_request_target_branch: Some("main".to_string()),
            review_request_title: Some("Add forge review support".to_string()),
            review_request_web_url: Some(
                "https://github.com/agentty-xyz/agentty/pull/42".to_string(),
            ),
            size: "M".to_string(),
            status: "Review".to_string(),
            summary: Some("Summary text".to_string()),
            title: Some("Review session".to_string()),
            updated_at: 200,
        }
    }
}

/// Row returned when loading one lightweight `session` list entry plus aliased
/// `session_review_request` join columns.
#[derive(sqlx::FromRow)]
struct SessionListJoinRow {
    added_lines: i64,
    base_branch: String,
    created_at: i64,
    deleted_lines: i64,
    id: String,
    in_progress_started_at: Option<i64>,
    in_progress_total_seconds: i64,
    input_tokens: i64,
    is_draft: bool,
    model: String,
    output_tokens: i64,
    parent_session_id: Option<String>,
    project_id: Option<i64>,
    reasoning_level_override: Option<String>,
    published_upstream_ref: Option<String>,
    review_request_display_id: Option<String>,
    review_request_forge_kind: Option<String>,
    review_request_last_refreshed_at: Option<i64>,
    review_request_source_branch: Option<String>,
    review_request_state: Option<String>,
    review_request_status_summary: Option<String>,
    review_request_target_branch: Option<String>,
    review_request_title: Option<String>,
    review_request_web_url: Option<String>,
    size: String,
    status: String,
    title: Option<String>,
    updated_at: i64,
}

impl SessionListJoinRow {
    /// Converts the macro-mapped list join row into a lightweight
    /// `SessionListRow`.
    fn into_session_list_row(self) -> SessionListRow {
        let Self {
            added_lines,
            base_branch,
            created_at,
            deleted_lines,
            id,
            in_progress_started_at,
            in_progress_total_seconds,
            input_tokens,
            is_draft,
            model,
            output_tokens,
            parent_session_id,
            project_id,
            reasoning_level_override,
            published_upstream_ref,
            review_request_display_id,
            review_request_forge_kind,
            review_request_last_refreshed_at,
            review_request_source_branch,
            review_request_state,
            review_request_status_summary,
            review_request_target_branch,
            review_request_title,
            review_request_web_url,
            size,
            status,
            title,
            updated_at,
        } = self;

        let review_request = SessionReviewRequestJoinRow {
            display_id: review_request_display_id,
            forge_kind: review_request_forge_kind,
            last_refreshed_at: review_request_last_refreshed_at,
            source_branch: review_request_source_branch,
            state: review_request_state,
            status_summary: review_request_status_summary,
            target_branch: review_request_target_branch,
            title: review_request_title,
            web_url: review_request_web_url,
        }
        .into_review_request_row();

        SessionListRow {
            added_lines,
            base_branch,
            created_at,
            deleted_lines,
            id,
            in_progress_started_at,
            in_progress_total_seconds,
            input_tokens,
            is_draft,
            model,
            output_tokens,
            parent_session_id,
            project_id,
            reasoning_level_override,
            published_upstream_ref,
            review_request,
            size,
            status,
            title,
            updated_at,
        }
    }
}

/// Aliased nullable `session_review_request` columns loaded through a joined
/// session query.
struct SessionReviewRequestJoinRow {
    display_id: Option<String>,
    forge_kind: Option<String>,
    last_refreshed_at: Option<i64>,
    source_branch: Option<String>,
    state: Option<String>,
    status_summary: Option<String>,
    target_branch: Option<String>,
    title: Option<String>,
    web_url: Option<String>,
}

impl SessionReviewRequestJoinRow {
    /// Converts the joined nullable columns into a review-request row only
    /// when every required field is present.
    fn into_review_request_row(self) -> Option<SessionReviewRequestRow> {
        let Self {
            display_id,
            forge_kind,
            last_refreshed_at,
            source_branch,
            state,
            status_summary,
            target_branch,
            title,
            web_url,
        } = self;

        Some(SessionReviewRequestRow {
            display_id: display_id?,
            forge_kind: forge_kind?,
            last_refreshed_at: last_refreshed_at?,
            source_branch: source_branch?,
            state: state?,
            status_summary,
            target_branch: target_branch?,
            title: title?,
            web_url: web_url?,
        })
    }
}

#[async_trait]
impl SessionRepository for SqliteSessionRepository {
    async fn append_session_output(&self, id: &str, chunk: &str) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET output = output || ?
WHERE id = ?
",
        )
        .bind(chunk)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn backfill_session_project(&self, project_id: i64) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET project_id = ?
WHERE project_id IS NULL
",
        )
        .bind(project_id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn delete_session(&self, id: &str) -> Result<(), DbError> {
        sqlx::query(
            r"
DELETE FROM session
WHERE id = ?
",
        )
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn get_session_base_branch(&self, id: &str) -> Result<Option<String>, DbError> {
        let row = sqlx::query_as!(
            RequiredStringValueRow,
            r#"
SELECT base_branch AS "value!: _"
FROM session
WHERE id = ?
"#,
            id
        )
        .fetch_optional(&self.0)
        .await?;

        Ok(row.map(|row| row.value))
    }

    async fn get_session_instruction_conversation_id(
        &self,
        id: &str,
    ) -> Result<Option<String>, DbError> {
        let row = sqlx::query_as::<_, SessionInstructionStateRow>(
            r"
SELECT app_server_instruction_provider_conversation_id
FROM session
WHERE id = ?
",
        )
        .bind(id)
        .fetch_optional(&self.0)
        .await?;

        Ok(row.and_then(SessionInstructionStateRow::into_instruction_conversation_id))
    }

    async fn get_session_provider_conversation_id(
        &self,
        id: &str,
    ) -> Result<Option<String>, DbError> {
        let value = sqlx::query_scalar!(
            r"SELECT provider_conversation_id FROM session WHERE id = ?",
            id
        )
        .fetch_optional(&self.0)
        .await?
        .flatten();

        Ok(value)
    }

    async fn insert_draft_session(
        &self,
        id: &str,
        model: &str,
        base_branch: &str,
        status: &str,
        project_id: i64,
    ) -> Result<(), DbError> {
        insert_session_with_draft_mode(
            &self.0,
            InsertSessionRow {
                base_branch,
                id,
                is_draft: true,
                model,
                parent_session_id: None,
                project_id,
                status,
            },
        )
        .await
    }

    async fn insert_stacked_draft_session(
        &self,
        id: &str,
        model: &str,
        base_branch: &str,
        status: &str,
        parent_session_id: &str,
        project_id: i64,
    ) -> Result<(), DbError> {
        insert_session_with_draft_mode(
            &self.0,
            InsertSessionRow {
                base_branch,
                id,
                is_draft: true,
                model,
                parent_session_id: Some(parent_session_id),
                project_id,
                status,
            },
        )
        .await
    }

    async fn insert_session(
        &self,
        id: &str,
        model: &str,
        base_branch: &str,
        status: &str,
        project_id: i64,
    ) -> Result<(), DbError> {
        insert_session_with_draft_mode(
            &self.0,
            InsertSessionRow {
                base_branch,
                id,
                is_draft: false,
                model,
                parent_session_id: None,
                project_id,
                status,
            },
        )
        .await
    }

    #[cfg(test)]
    async fn load_sessions(&self) -> Result<Vec<SessionRow>, DbError> {
        let rows = sqlx::query_as!(
            SessionJoinRow,
            r#"
SELECT session.base_branch AS "base_branch!",
       session.added_lines AS "added_lines!",
       session.created_at AS "created_at!",
       session.deleted_lines AS "deleted_lines!",
       session.id AS "id!",
       session.in_progress_started_at,
       session.in_progress_total_seconds AS "in_progress_total_seconds!",
       session.input_tokens AS "input_tokens!",
       session.is_draft AS "is_draft!: bool",
       session.model AS "model!",
       session.output AS "output!",
       session.output_tokens AS "output_tokens!",
       session.parent_session_id,
       session.project_id,
       session.prompt AS "prompt!",
       session.reasoning_level AS "reasoning_level_override?",
       session.published_upstream_ref,
       session.questions,
       session_review_request.display_id AS "review_request_display_id?",
       session_review_request.forge_kind AS "review_request_forge_kind?",
       session_review_request.last_refreshed_at AS "review_request_last_refreshed_at?",
       session_review_request.source_branch AS "review_request_source_branch?",
       session_review_request.state AS "review_request_state?",
       session_review_request.status_summary AS "review_request_status_summary?",
       session_review_request.target_branch AS "review_request_target_branch?",
       session_review_request.title AS "review_request_title?",
       session_review_request.web_url AS "review_request_web_url?",
       session.size AS "size!",
       session.status AS "status!",
       session.summary,
       session.title,
       session.updated_at AS "updated_at!"
FROM session
LEFT JOIN session_review_request
ON session_review_request.session_id = session.id
ORDER BY session.updated_at DESC, session.id
"#
        )
        .fetch_all(&self.0)
        .await?;

        Ok(rows
            .into_iter()
            .map(SessionJoinRow::into_session_row)
            .collect())
    }

    async fn load_sessions_for_project(
        &self,
        project_id: i64,
    ) -> Result<Vec<SessionListRow>, DbError> {
        let rows = sqlx::query_as!(
            SessionListJoinRow,
            r#"
SELECT session.base_branch AS "base_branch!",
       session.added_lines AS "added_lines!",
       session.created_at AS "created_at!",
       session.deleted_lines AS "deleted_lines!",
       session.id AS "id!",
       session.in_progress_started_at,
       session.in_progress_total_seconds AS "in_progress_total_seconds!",
       session.input_tokens AS "input_tokens!",
       session.is_draft AS "is_draft!: bool",
       session.model AS "model!",
       session.output_tokens AS "output_tokens!",
       session.parent_session_id,
       session.project_id,
       session.reasoning_level AS "reasoning_level_override?",
       session.published_upstream_ref,
       session_review_request.display_id AS "review_request_display_id?",
       session_review_request.forge_kind AS "review_request_forge_kind?",
       session_review_request.last_refreshed_at AS "review_request_last_refreshed_at?",
       session_review_request.source_branch AS "review_request_source_branch?",
       session_review_request.state AS "review_request_state?",
       session_review_request.status_summary AS "review_request_status_summary?",
       session_review_request.target_branch AS "review_request_target_branch?",
       session_review_request.title AS "review_request_title?",
       session_review_request.web_url AS "review_request_web_url?",
       session.size AS "size!",
       session.status AS "status!",
       session.title,
       session.updated_at AS "updated_at!"
FROM session
LEFT JOIN session_review_request
ON session_review_request.session_id = session.id
WHERE session.project_id = ?
ORDER BY session.updated_at DESC, session.id
"#,
            project_id
        )
        .fetch_all(&self.0)
        .await?;

        Ok(rows
            .into_iter()
            .map(SessionListJoinRow::into_session_list_row)
            .collect())
    }

    async fn load_session_detail(
        &self,
        session_id: &str,
    ) -> Result<Option<SessionDetailRow>, DbError> {
        let row = sqlx::query_as!(
            SessionDetailRow,
            r#"
SELECT output AS "output!",
       prompt AS "prompt!",
       questions,
       summary
FROM session
WHERE id = ?
"#,
            session_id
        )
        .fetch_optional(&self.0)
        .await?;

        Ok(row)
    }

    async fn load_session_follow_up_tasks(&self) -> Result<Vec<SessionFollowUpTaskRow>, DbError> {
        let rows = match sqlx::query_as::<_, SessionFollowUpTaskRow>(
            r"
SELECT id,
       launched_session_id,
       position,
       session_id,
       text
FROM session_follow_up_task
ORDER BY session_id, position, id
",
        )
        .fetch_all(&self.0)
        .await
        {
            Ok(rows) => rows,
            Err(error) if is_missing_follow_up_task_table(&error) => return Ok(Vec::new()),
            Err(error) => return Err(error.into()),
        };

        Ok(rows)
    }

    async fn load_session_focused_reviews_for_project(
        &self,
        project_id: i64,
    ) -> Result<Vec<SessionFocusedReviewRow>, DbError> {
        let rows = sqlx::query_as::<_, SessionFocusedReviewRow>(
            r"
SELECT id AS session_id,
       focused_review_diff_hash AS diff_hash,
       focused_review_text AS text
FROM session
WHERE project_id = ?
  AND focused_review_diff_hash IS NOT NULL
  AND focused_review_text IS NOT NULL
  AND focused_review_text <> ''
ORDER BY updated_at DESC, id
",
        )
        .bind(project_id)
        .fetch_all(&self.0)
        .await?;

        Ok(rows)
    }

    async fn load_sessions_metadata(&self) -> Result<(i64, i64), DbError> {
        let row = sqlx::query_as!(
            SessionMetadataRow,
            r#"
SELECT (SELECT COUNT(*) FROM session) AS "session_count!: _",
       COALESCE(
           (
               SELECT updated_at
               FROM session
               ORDER BY updated_at DESC, id
               LIMIT 1
           ),
           0
       ) AS "max_updated_at!: _"
"#
        )
        .fetch_one(&self.0)
        .await?;

        Ok((row.session_count, row.max_updated_at))
    }

    async fn load_session_project_id(&self, session_id: &str) -> Result<Option<i64>, DbError> {
        let row = sqlx::query_as!(
            OptionalI64ValueRow,
            r#"
SELECT project_id AS "value: _"
FROM session
WHERE id = ?
"#,
            session_id
        )
        .fetch_optional(&self.0)
        .await?;

        Ok(row.and_then(|row| row.value))
    }

    async fn load_session_published_upstream_ref(
        &self,
        id: &str,
    ) -> Result<Option<String>, DbError> {
        let value = sqlx::query_scalar!(
            r"SELECT published_upstream_ref FROM session WHERE id = ?",
            id
        )
        .fetch_optional(&self.0)
        .await?
        .flatten();

        Ok(value)
    }

    async fn load_session_merged_commit_hash(
        &self,
        session_id: &str,
    ) -> Result<Option<String>, DbError> {
        let row = sqlx::query_scalar::<_, Option<String>>(
            r"
SELECT merged_commit_hash
FROM session
WHERE id = ?
",
        )
        .bind(session_id)
        .fetch_optional(&self.0)
        .await?;

        Ok(row.flatten())
    }

    async fn load_session_reasoning_level_override(
        &self,
        session_id: &str,
    ) -> Result<Option<ReasoningLevel>, DbError> {
        let value = sqlx::query_scalar!(
            r"SELECT reasoning_level FROM session WHERE id = ?",
            session_id
        )
        .fetch_optional(&self.0)
        .await?
        .flatten();

        Ok(value.and_then(|value| value.parse::<ReasoningLevel>().ok()))
    }

    async fn restack_child_sessions_after_parent_merge(
        &self,
        parent_session_id: &str,
        base_branch: &str,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET parent_session_id = NULL,
    base_branch = ?
WHERE parent_session_id = ?
  AND status <> 'Canceled'
",
        )
        .bind(base_branch)
        .bind(parent_session_id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn load_session_summary(&self, session_id: &str) -> Result<Option<String>, DbError> {
        let row = sqlx::query_scalar::<_, Option<String>>(
            r"
SELECT summary
FROM session
WHERE id = ?
",
        )
        .bind(session_id)
        .fetch_optional(&self.0)
        .await?;

        Ok(row.flatten())
    }

    async fn load_session_timestamps(
        &self,
        session_id: &str,
    ) -> Result<Option<(i64, i64)>, DbError> {
        let row = sqlx::query_as!(
            SessionTimestampsRow,
            r#"
SELECT created_at, updated_at
FROM session
WHERE id = ?
            "#,
            session_id
        )
        .fetch_optional(&self.0)
        .await?;

        Ok(row.map(|row| (row.created_at, row.updated_at)))
    }

    async fn persist_session_turn_metadata(
        &self,
        session_id: &str,
        turn_metadata: &SessionTurnMetadata,
    ) -> Result<(), DbError> {
        let mut transaction = self.0.begin().await?;

        let session_update = sqlx::query(
            r"
UPDATE session
SET questions = ?,
    summary = ?,
    provider_conversation_id = ?,
    app_server_instruction_provider_conversation_id = ?
WHERE id = ?
",
        )
        .bind(turn_metadata.questions_json.as_str())
        .bind(turn_metadata.summary.as_str())
        .bind(turn_metadata.provider_conversation_id.as_deref())
        .bind(turn_metadata.instruction_conversation_id.as_deref())
        .bind(session_id)
        .execute(&mut *transaction)
        .await?;
        if session_update.rows_affected() != 1 {
            return Err(sqlx::Error::RowNotFound.into());
        }

        if turn_metadata.token_usage_delta.input_tokens != 0
            || turn_metadata.token_usage_delta.output_tokens != 0
        {
            sqlx::query(
                r"
UPDATE session
SET input_tokens = input_tokens + ?,
    output_tokens = output_tokens + ?
WHERE id = ?
",
            )
            .bind(turn_metadata.token_usage_delta.input_tokens.cast_signed())
            .bind(turn_metadata.token_usage_delta.output_tokens.cast_signed())
            .bind(session_id)
            .execute(&mut *transaction)
            .await?;

            sqlx::query(
                r"
INSERT INTO session_usage (session_id, model, input_tokens, output_tokens, invocation_count)
VALUES (?, ?, ?, ?, 1)
ON CONFLICT(session_id, model) DO UPDATE SET
    input_tokens = input_tokens + excluded.input_tokens,
    output_tokens = output_tokens + excluded.output_tokens,
    invocation_count = invocation_count + 1
",
            )
            .bind(session_id)
            .bind(turn_metadata.model.as_str())
            .bind(turn_metadata.token_usage_delta.input_tokens.cast_signed())
            .bind(turn_metadata.token_usage_delta.output_tokens.cast_signed())
            .execute(&mut *transaction)
            .await?;
        }

        transaction.commit().await?;

        Ok(())
    }

    #[cfg(test)]
    async fn replace_session_output(&self, id: &str, output: &str) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET output = ?
WHERE id = ?
",
        )
        .bind(output)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn replace_session_follow_up_tasks(
        &self,
        session_id: &str,
        follow_up_tasks: &[String],
    ) -> Result<(), DbError> {
        let mut transaction = self.0.begin().await?;

        let delete_result = sqlx::query(
            r"
DELETE FROM session_follow_up_task
WHERE session_id = ?
",
        )
        .bind(session_id)
        .execute(&mut *transaction)
        .await;
        match delete_result {
            Ok(_) => {}
            Err(error) if is_missing_follow_up_task_table(&error) => {
                transaction.rollback().await?;
                return Ok(());
            }
            Err(error) => {
                transaction.rollback().await?;
                return Err(error.into());
            }
        }

        for (position, follow_up_task) in follow_up_tasks.iter().enumerate() {
            sqlx::query(
                r"
INSERT INTO session_follow_up_task (session_id, position, text)
VALUES (?, ?, ?)
",
            )
            .bind(session_id)
            .bind(i64::try_from(position).unwrap_or(i64::MAX))
            .bind(follow_up_task)
            .execute(&mut *transaction)
            .await?;
        }

        transaction.commit().await?;

        Ok(())
    }

    async fn update_session_diff_stats(
        &self,
        added_lines: u64,
        deleted_lines: u64,
        id: &str,
        size: &str,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET added_lines = ?,
    deleted_lines = ?,
    size = ?
WHERE id = ?
  AND (
      added_lines <> ?
      OR deleted_lines <> ?
      OR size <> ?
  )
",
        )
        .bind(added_lines.cast_signed())
        .bind(deleted_lines.cast_signed())
        .bind(size)
        .bind(id)
        .bind(added_lines.cast_signed())
        .bind(deleted_lines.cast_signed())
        .bind(size)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_follow_up_task_launched_session_id(
        &self,
        session_id: &str,
        position: usize,
        launched_session_id: Option<String>,
    ) -> Result<(), DbError> {
        let update_result = sqlx::query(
            r"
UPDATE session_follow_up_task
SET launched_session_id = ?
WHERE session_id = ?
  AND position = ?
",
        )
        .bind(launched_session_id.as_deref())
        .bind(session_id)
        .bind(i64::try_from(position).unwrap_or(i64::MAX))
        .execute(&self.0)
        .await;
        match update_result {
            Ok(_) => {}
            Err(error) if is_missing_follow_up_task_table(&error) => return Ok(()),
            Err(error) => return Err(error.into()),
        }

        Ok(())
    }

    async fn update_session_instruction_conversation_id(
        &self,
        id: &str,
        provider_conversation_id: Option<String>,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET app_server_instruction_provider_conversation_id = ?
WHERE id = ?
",
        )
        .bind(provider_conversation_id.as_deref())
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_model(&self, id: &str, model: &str) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET model = ?
WHERE id = ?
",
        )
        .bind(model)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_merged_commit_hash(
        &self,
        id: &str,
        merged_commit_hash: Option<String>,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET merged_commit_hash = ?
WHERE id = ?
",
        )
        .bind(merged_commit_hash.as_deref())
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_prompt(&self, id: &str, prompt: &str) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET prompt = ?
WHERE id = ?
",
        )
        .bind(prompt)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_provider_conversation_id(
        &self,
        id: &str,
        provider_conversation_id: Option<String>,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET provider_conversation_id = ?
WHERE id = ?
",
        )
        .bind(provider_conversation_id.as_deref())
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_questions(&self, id: &str, questions: &str) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET questions = ?
WHERE id = ?
",
        )
        .bind(questions)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_reasoning_level(
        &self,
        id: &str,
        reasoning_level: Option<String>,
    ) -> Result<(), DbError> {
        sqlx::query!(
            r#"
UPDATE session
SET reasoning_level = ?
WHERE id = ?
            "#,
            reasoning_level,
            id
        )
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_published_upstream_ref(
        &self,
        id: &str,
        published_upstream_ref: Option<String>,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET published_upstream_ref = ?
WHERE id = ?
",
        )
        .bind(published_upstream_ref.as_deref())
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_stats(&self, id: &str, stats: &SessionStats) -> Result<(), DbError> {
        if stats.input_tokens == 0 && stats.output_tokens == 0 {
            return Ok(());
        }

        sqlx::query(
            r"
UPDATE session
SET input_tokens = input_tokens + ?,
    output_tokens = output_tokens + ?
WHERE id = ?
",
        )
        .bind(stats.input_tokens.cast_signed())
        .bind(stats.output_tokens.cast_signed())
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_status_with_timing_at(
        &self,
        id: &str,
        status: &str,
        timestamp_seconds: i64,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET status = ?,
    in_progress_total_seconds = CASE
        WHEN ? = 'InProgress' OR in_progress_started_at IS NULL THEN in_progress_total_seconds
        ELSE in_progress_total_seconds + MAX(0, ? - in_progress_started_at)
    END,
    in_progress_started_at = CASE
        WHEN ? = 'InProgress' THEN COALESCE(in_progress_started_at, ?)
        ELSE NULL
    END
WHERE id = ?
",
        )
        .bind(status)
        .bind(status)
        .bind(timestamp_seconds)
        .bind(status)
        .bind(timestamp_seconds)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_summary(&self, id: &str, summary: &str) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET summary = ?
WHERE id = ?
",
        )
        .bind(summary)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_focused_review(
        &self,
        id: &str,
        diff_hash: Option<String>,
        text: Option<String>,
    ) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET focused_review_diff_hash = ?,
    focused_review_text = ?
WHERE id = ?
",
        )
        .bind(diff_hash.as_deref())
        .bind(text.as_deref())
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_title(&self, id: &str, title: &str) -> Result<(), DbError> {
        sqlx::query!(
            r#"
UPDATE session
SET title = ?
WHERE id = ?
"#,
            title,
            id,
        )
        .execute(&self.0)
        .await?;

        Ok(())
    }

    async fn update_session_title_for_prompt(
        &self,
        id: &str,
        expected_prompt: &str,
        title: &str,
    ) -> Result<bool, DbError> {
        let result = sqlx::query!(
            r#"
UPDATE session
SET title = ?
WHERE id = ?
  AND prompt = ?
"#,
            title,
            id,
            expected_prompt,
        )
        .execute(&self.0)
        .await?;

        Ok(result.rows_affected() > 0)
    }

    #[cfg(test)]
    async fn update_session_created_at(&self, id: &str, created_at: i64) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET created_at = ?
WHERE id = ?
",
        )
        .bind(created_at)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }

    #[cfg(test)]
    async fn update_session_updated_at(&self, id: &str, updated_at: i64) -> Result<(), DbError> {
        sqlx::query(
            r"
UPDATE session
SET updated_at = ?
WHERE id = ?
",
        )
        .bind(updated_at)
        .bind(id)
        .execute(&self.0)
        .await?;

        Ok(())
    }
}

/// Borrowed values used to insert one newly created session row.
struct InsertSessionRow<'a> {
    /// Base branch or parent branch used for future worktree materialization.
    base_branch: &'a str,
    /// Stable session identifier.
    id: &'a str,
    /// Whether the row was created through explicit draft staging.
    is_draft: bool,
    /// Agent model identifier persisted for the session.
    model: &'a str,
    /// Optional parent session id for one-level stacked drafts.
    parent_session_id: Option<&'a str>,
    /// Owning project identifier.
    project_id: i64,
    /// Initial lifecycle status string.
    status: &'a str,
}

/// Inserts one newly created session row with explicit draft-mode
/// persistence.
async fn insert_session_with_draft_mode(
    pool: &SqlitePool,
    row: InsertSessionRow<'_>,
) -> Result<(), DbError> {
    let InsertSessionRow {
        base_branch,
        id,
        is_draft,
        model,
        parent_session_id,
        project_id,
        status,
    } = row;

    sqlx::query(
        r"
INSERT INTO session (
    id,
    model,
    base_branch,
    status,
    is_draft,
    parent_session_id,
    project_id,
    prompt,
    output
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
",
    )
    .bind(id)
    .bind(model)
    .bind(base_branch)
    .bind(status)
    .bind(is_draft)
    .bind(parent_session_id)
    .bind(project_id)
    .bind("")
    .bind("")
    .execute(pool)
    .await?;

    Ok(())
}

/// Returns whether one `SQLx` error indicates the optional follow-up-task table
/// is not available in the current database.
fn is_missing_follow_up_task_table(error: &sqlx::Error) -> bool {
    matches!(
        error,
        sqlx::Error::Database(database_error)
            if database_error.message().contains("no such table: session_follow_up_task")
    )
}

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

    #[test]
    fn test_session_follow_up_task_row_converts_to_domain_task() {
        // Arrange
        let row = SessionFollowUpTaskRow {
            id: 7,
            launched_session_id: Some("launched-session".to_string()),
            position: 3,
            session_id: "source-session".to_string(),
            text: "Follow up on coverage".to_string(),
        };

        // Act
        let follow_up_task = row.into_session_follow_up_task();

        // Assert
        assert_eq!(follow_up_task.id, 7);
        assert_eq!(
            follow_up_task.launched_session_id,
            Some(SessionId::from("launched-session"))
        );
        assert_eq!(follow_up_task.position, 3);
        assert_eq!(follow_up_task.text, "Follow up on coverage");
    }

    #[test]
    fn test_session_follow_up_task_row_clamps_invalid_position() {
        // Arrange
        let row = SessionFollowUpTaskRow {
            id: 8,
            launched_session_id: None,
            position: -1,
            session_id: "source-session".to_string(),
            text: "Handle invalid position".to_string(),
        };

        // Act
        let follow_up_task = row.into_session_follow_up_task();

        // Assert
        assert_eq!(follow_up_task.launched_session_id, None);
        assert_eq!(follow_up_task.position, usize::MAX);
    }
}