room_plugin_taskboard/

lib.rs

mod handlers;
pub mod task;

use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use std::time::Duration;

use task::{next_id, LiveTask, Task, TaskStatus};

use room_protocol::plugin::{
    BoxFuture, CommandContext, CommandInfo, ParamSchema, ParamType, Plugin, PluginResult,
};
use room_protocol::EventType;

// ── C ABI entry points for cdylib loading ─────────────────────────────────

/// JSON configuration for the taskboard plugin when loaded dynamically.
///
/// `lease_ttl_secs` defaults to `0` (expiry disabled). Set a positive value
/// to enable automatic lease expiry (e.g. `600` for 10 minutes).
///
/// ```json
/// { "storage_path": "/path/to/room.taskboard", "lease_ttl_secs": 0 }
/// ```
#[derive(serde::Deserialize)]
struct TaskboardConfig {
    storage_path: PathBuf,
    #[serde(default)]
    lease_ttl_secs: Option<u64>,
}

/// Create a [`TaskboardPlugin`] from a JSON config string.
///
/// Falls back to a temp-file default if config is empty (for testing).
fn create_taskboard_from_config(config: &str) -> TaskboardPlugin {
    if config.is_empty() {
        // Default: use a temp path — useful for tests, not for production.
        TaskboardPlugin::new(PathBuf::from("/tmp/room-default.taskboard"), None)
    } else {
        let cfg: TaskboardConfig =
            serde_json::from_str(config).expect("invalid taskboard plugin config JSON");
        TaskboardPlugin::new(cfg.storage_path, cfg.lease_ttl_secs)
    }
}

room_protocol::declare_plugin!("taskboard", create_taskboard_from_config);

/// Default lease TTL in seconds. `0` means lease expiry is disabled (no
/// auto-release). Set a non-zero value via config to enable time-based expiry.
const DEFAULT_LEASE_TTL_SECS: u64 = 0;

/// Unified task lifecycle plugin with optional lease-based expiry.
///
/// Manages a board of tasks that agents can post, claim, plan, get approved,
/// update, release, and finish. When `lease_ttl_secs` is non-zero, claimed
/// tasks auto-release back to open status if not renewed via `/taskboard
/// update` or `/taskboard plan` within the TTL (lazy sweep on access). When
/// zero (the default), leases are tracked but never expire.
pub struct TaskboardPlugin {
    /// In-memory task board with lease timers.
    board: Arc<Mutex<Vec<LiveTask>>>,
    /// Path to the NDJSON persistence file.
    storage_path: PathBuf,
    /// Lease TTL duration.
    lease_ttl: Duration,
}

impl TaskboardPlugin {
    /// Create a new taskboard plugin, loading existing tasks from disk.
    pub fn new(storage_path: PathBuf, lease_ttl_secs: Option<u64>) -> Self {
        let ttl = lease_ttl_secs.unwrap_or(DEFAULT_LEASE_TTL_SECS);
        let tasks = task::load_tasks(&storage_path);
        let live_tasks: Vec<LiveTask> = tasks.into_iter().map(LiveTask::new).collect();
        Self {
            board: Arc::new(Mutex::new(live_tasks)),
            storage_path,
            lease_ttl: Duration::from_secs(ttl),
        }
    }

    /// Derive the `.taskboard` file path from a `.chat` file path.
    pub fn taskboard_path_from_chat(chat_path: &std::path::Path) -> PathBuf {
        chat_path.with_extension("taskboard")
    }

    /// Returns the command info for the TUI command palette without needing
    /// an instantiated plugin. Used by `all_known_commands()`.
    pub fn default_commands() -> Vec<CommandInfo> {
        vec![CommandInfo {
            name: "taskboard".to_owned(),
            description:
                "Manage task lifecycle — post, list, history, mine, qa-queue, show, claim, assign, plan, approve, update, request_review, review_claim, reject, release, finish, cancel"
                    .to_owned(),
            usage: "/taskboard <action> [args...]".to_owned(),
            params: vec![
                ParamSchema {
                    name: "action".to_owned(),
                    param_type: ParamType::Choice(vec![
                        "post".to_owned(),
                        "list".to_owned(),
                        "history".to_owned(),
                        "mine".to_owned(),
                        "qa-queue".to_owned(),
                        "show".to_owned(),
                        "claim".to_owned(),
                        "assign".to_owned(),
                        "plan".to_owned(),
                        "approve".to_owned(),
                        "update".to_owned(),
                        "request_review".to_owned(),
                        "review_claim".to_owned(),
                        "reject".to_owned(),
                        "release".to_owned(),
                        "finish".to_owned(),
                        "cancel".to_owned(),
                    ]),
                    required: true,
                    description: "Subcommand".to_owned(),
                },
                ParamSchema {
                    name: "args".to_owned(),
                    param_type: ParamType::Text,
                    required: false,
                    description: "Task ID or description".to_owned(),
                },
            ],
            subcommands: taskboard_subcommands(),
        }]
    }

    /// Sweep expired leases (lazy — called before reads).
    ///
    /// Returns immediately when the TTL is zero (expiry disabled).
    fn sweep_expired(&self) -> Vec<String> {
        let ttl = self.lease_ttl.as_secs();
        if ttl == 0 {
            return Vec::new();
        }
        let mut board = self.board.lock().unwrap();
        let mut expired_ids = Vec::new();
        for lt in board.iter_mut() {
            if lt.is_expired(ttl)
                && matches!(
                    lt.task.status,
                    TaskStatus::Claimed
                        | TaskStatus::Planned
                        | TaskStatus::InProgress
                        | TaskStatus::ReviewClaimed
                )
            {
                let prev_assignee = lt.task.assigned_to.clone().unwrap_or_default();
                expired_ids.push(format!("{} (was {})", lt.task.id, prev_assignee));
                lt.expire();
            }
        }
        if !expired_ids.is_empty() {
            let tasks: Vec<Task> = board.iter().map(|lt| lt.task.clone()).collect();
            let _ = task::save_tasks(&self.storage_path, &tasks);
        }
        expired_ids
    }
}

/// Build the per-subcommand help schemas for `/help taskboard <sub>`.
fn taskboard_subcommands() -> Vec<CommandInfo> {
    vec![
        CommandInfo {
            name: "post".to_owned(),
            description: "Create a new task on the board. Anyone can post.".to_owned(),
            usage: "/taskboard post <description>".to_owned(),
            params: vec![ParamSchema {
                name: "description".to_owned(),
                param_type: ParamType::Text,
                required: true,
                description: "Task description".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "list".to_owned(),
            description: "Show all active tasks. Use 'list all' to include finished/cancelled.".to_owned(),
            usage: "/taskboard list [all]".to_owned(),
            params: vec![ParamSchema {
                name: "all".to_owned(),
                param_type: ParamType::Choice(vec!["all".to_owned()]),
                required: false,
                description: "Include finished and cancelled tasks".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "show".to_owned(),
            description: "Show full detail for a single task.".to_owned(),
            usage: "/taskboard show <task-id>".to_owned(),
            params: vec![ParamSchema {
                name: "task-id".to_owned(),
                param_type: ParamType::Text,
                required: true,
                description: "Task ID (e.g. tb-001)".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "claim".to_owned(),
            description: "Claim an open task. Starts the lease timer. Task must be in Open status.".to_owned(),
            usage: "/taskboard claim <task-id>".to_owned(),
            params: vec![ParamSchema {
                name: "task-id".to_owned(),
                param_type: ParamType::Text,
                required: true,
                description: "Task ID (e.g. tb-001)".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "assign".to_owned(),
            description: "Assign an open task to a specific user. Only the poster or host can assign.".to_owned(),
            usage: "/taskboard assign <task-id> <username>".to_owned(),
            params: vec![
                ParamSchema {
                    name: "task-id".to_owned(),
                    param_type: ParamType::Text,
                    required: true,
                    description: "Task ID (e.g. tb-001)".to_owned(),
                },
                ParamSchema {
                    name: "username".to_owned(),
                    param_type: ParamType::Username,
                    required: true,
                    description: "User to assign the task to".to_owned(),
                },
            ],
            subcommands: vec![],
        },
        CommandInfo {
            name: "plan".to_owned(),
            description: "Submit an implementation plan. Task must be in Claimed status and you must be the assignee. Wait for approval before implementing.".to_owned(),
            usage: "/taskboard plan <task-id> <plan-text>".to_owned(),
            params: vec![
                ParamSchema {
                    name: "task-id".to_owned(),
                    param_type: ParamType::Text,
                    required: true,
                    description: "Task ID (e.g. tb-001)".to_owned(),
                },
                ParamSchema {
                    name: "plan-text".to_owned(),
                    param_type: ParamType::Text,
                    required: true,
                    description: "Your implementation plan".to_owned(),
                },
            ],
            subcommands: vec![],
        },
        CommandInfo {
            name: "approve".to_owned(),
            description: "Approve a planned task so the assignee can proceed. Only the poster or host can approve.".to_owned(),
            usage: "/taskboard approve <task-id>".to_owned(),
            params: vec![ParamSchema {
                name: "task-id".to_owned(),
                param_type: ParamType::Text,
                required: true,
                description: "Task ID (e.g. tb-001)".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "update".to_owned(),
            description: "Renew the lease timer and optionally add progress notes. Only the assignee can update.".to_owned(),
            usage: "/taskboard update <task-id> [notes]".to_owned(),
            params: vec![
                ParamSchema {
                    name: "task-id".to_owned(),
                    param_type: ParamType::Text,
                    required: true,
                    description: "Task ID (e.g. tb-001)".to_owned(),
                },
                ParamSchema {
                    name: "notes".to_owned(),
                    param_type: ParamType::Text,
                    required: false,
                    description: "Progress notes".to_owned(),
                },
            ],
            subcommands: vec![],
        },
        CommandInfo {
            name: "review".to_owned(),
            description: "Mark a task as ready for review. Only the assignee can request review.".to_owned(),
            usage: "/taskboard review <task-id>".to_owned(),
            params: vec![ParamSchema {
                name: "task-id".to_owned(),
                param_type: ParamType::Text,
                required: true,
                description: "Task ID (e.g. tb-001)".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "release".to_owned(),
            description: "Release a task back to Open status. The assignee or host can release.".to_owned(),
            usage: "/taskboard release <task-id>".to_owned(),
            params: vec![ParamSchema {
                name: "task-id".to_owned(),
                param_type: ParamType::Text,
                required: true,
                description: "Task ID (e.g. tb-001)".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "finish".to_owned(),
            description: "Mark a task as finished. Only the assignee can finish.".to_owned(),
            usage: "/taskboard finish <task-id>".to_owned(),
            params: vec![ParamSchema {
                name: "task-id".to_owned(),
                param_type: ParamType::Text,
                required: true,
                description: "Task ID (e.g. tb-001)".to_owned(),
            }],
            subcommands: vec![],
        },
        CommandInfo {
            name: "cancel".to_owned(),
            description: "Cancel a task with an optional reason. The poster, assignee, or host can cancel.".to_owned(),
            usage: "/taskboard cancel <task-id> [reason]".to_owned(),
            params: vec![
                ParamSchema {
                    name: "task-id".to_owned(),
                    param_type: ParamType::Text,
                    required: true,
                    description: "Task ID (e.g. tb-001)".to_owned(),
                },
                ParamSchema {
                    name: "reason".to_owned(),
                    param_type: ParamType::Text,
                    required: false,
                    description: "Cancellation reason".to_owned(),
                },
            ],
            subcommands: vec![],
        },
        CommandInfo {
            name: "mine".to_owned(),
            description: "Show only tasks assigned to you.".to_owned(),
            usage: "/taskboard mine".to_owned(),
            params: vec![],
            subcommands: vec![],
        },
    ]
}

impl Plugin for TaskboardPlugin {
    fn name(&self) -> &str {
        "taskboard"
    }

    fn version(&self) -> &str {
        env!("CARGO_PKG_VERSION")
    }

    fn commands(&self) -> Vec<CommandInfo> {
        Self::default_commands()
    }

    fn handle(&self, ctx: CommandContext) -> BoxFuture<'_, anyhow::Result<PluginResult>> {
        Box::pin(async move {
            let action = ctx.params.first().map(String::as_str).unwrap_or("");
            let (result, broadcast) = match action {
                "post" => self.handle_post(&ctx),
                "list" => {
                    let show_all = ctx.params.get(1).map(|s| s.as_str()) == Some("all");
                    (self.handle_list(show_all), false)
                }
                "history" => (self.handle_history(), false),
                "mine" => (self.handle_mine(&ctx.sender), false),
                "qa-queue" => (self.handle_qa_queue(), false),
                "claim" => self.handle_claim(&ctx),
                "assign" => self.handle_assign(&ctx),
                "plan" => self.handle_plan(&ctx),
                "approve" => self.handle_approve(&ctx),
                "show" => (self.handle_show(&ctx), false),
                "update" => self.handle_update(&ctx),
                "release" => self.handle_release(&ctx),
                "request_review" => self.handle_request_review(&ctx),
                "review_claim" => self.handle_review_claim(&ctx),
                "reject" => self.handle_reject(&ctx),
                "finish" => self.handle_finish(&ctx),
                "cancel" => self.handle_cancel(&ctx),
                "" => ("usage: /taskboard <post|list|history|mine|qa-queue|show|claim|assign|plan|approve|update|request_review|review_claim|reject|release|finish|cancel> [args...]".to_owned(), false),
                other => (format!("unknown action: {other}. use: post, list, history, mine, qa-queue, show, claim, assign, plan, approve, update, request_review, review_claim, reject, release, finish, cancel"), false),
            };
            if broadcast {
                // Emit a typed event alongside the system broadcast.
                let event_type = match action {
                    "post" => Some(EventType::TaskPosted),
                    "claim" => Some(EventType::TaskClaimed),
                    "assign" => Some(EventType::TaskAssigned),
                    "plan" => Some(EventType::TaskPlanned),
                    "approve" => Some(EventType::TaskApproved),
                    "update" => Some(EventType::TaskUpdated),
                    "request_review" => Some(EventType::ReviewRequested),
                    "review_claim" => Some(EventType::ReviewClaimed),
                    "reject" => Some(EventType::TaskRejected),
                    "release" => Some(EventType::TaskReleased),
                    "finish" => Some(EventType::TaskFinished),
                    "cancel" => Some(EventType::TaskCancelled),
                    _ => None,
                };
                if let Some(et) = event_type {
                    let _ = ctx.writer.emit_event(et, &result, None).await;
                }
                Ok(PluginResult::Broadcast(result, None))
            } else {
                Ok(PluginResult::Reply(result, None))
            }
        })
    }
}

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

    fn make_plugin() -> (TaskboardPlugin, tempfile::NamedTempFile) {
        let tmp = tempfile::NamedTempFile::new().unwrap();
        let plugin = TaskboardPlugin::new(tmp.path().to_path_buf(), Some(600));
        (plugin, tmp)
    }

    #[test]
    fn plugin_name() {
        let (plugin, _tmp) = make_plugin();
        assert_eq!(plugin.name(), "taskboard");
    }

    #[test]
    fn plugin_version_matches_crate() {
        let (plugin, _tmp) = make_plugin();
        assert_eq!(plugin.version(), env!("CARGO_PKG_VERSION"));
    }

    #[test]
    fn plugin_api_version_is_current() {
        let (plugin, _tmp) = make_plugin();
        assert_eq!(
            plugin.api_version(),
            room_protocol::plugin::PLUGIN_API_VERSION
        );
    }

    #[test]
    fn plugin_min_protocol_is_compatible() {
        let (plugin, _tmp) = make_plugin();
        // Default min_protocol is "0.0.0", which is always satisfied.
        assert_eq!(plugin.min_protocol(), "0.0.0");
    }

    #[test]
    fn plugin_commands() {
        let (plugin, _tmp) = make_plugin();
        let cmds = plugin.commands();
        assert_eq!(cmds.len(), 1);
        assert_eq!(cmds[0].name, "taskboard");
        assert_eq!(cmds[0].params.len(), 2);
        if let ParamType::Choice(ref choices) = cmds[0].params[0].param_type {
            assert!(choices.contains(&"post".to_owned()));
            assert!(choices.contains(&"approve".to_owned()));
            assert!(choices.contains(&"assign".to_owned()));
            assert_eq!(choices.len(), 17);
        } else {
            panic!("expected Choice param type");
        }
    }

    #[test]
    fn plugin_commands_has_subcommands() {
        let (plugin, _tmp) = make_plugin();
        let cmds = plugin.commands();
        assert_eq!(cmds[0].subcommands.len(), 13, "should have 13 subcommands");
        let names: Vec<&str> = cmds[0]
            .subcommands
            .iter()
            .map(|s| s.name.as_str())
            .collect();
        assert!(names.contains(&"post"));
        assert!(names.contains(&"plan"));
        assert!(names.contains(&"claim"));
        assert!(names.contains(&"cancel"));
    }

    #[test]
    fn taskboard_path_from_chat_replaces_extension() {
        let chat = PathBuf::from("/data/room-dev.chat");
        let tb = TaskboardPlugin::taskboard_path_from_chat(&chat);
        assert_eq!(tb, PathBuf::from("/data/room-dev.taskboard"));
    }

    #[test]
    fn default_commands_matches_commands() {
        let (plugin, _tmp) = make_plugin();
        let default = TaskboardPlugin::default_commands();
        let instance = plugin.commands();
        assert_eq!(default.len(), instance.len());
        assert_eq!(default[0].name, instance[0].name);
        assert_eq!(default[0].params.len(), instance[0].params.len());
    }

    fn seed_task(plugin: &TaskboardPlugin, id: &str, status: TaskStatus) {
        let mut board = plugin.board.lock().unwrap();
        let t = task::Task {
            id: id.to_owned(),
            description: format!("task {id}"),
            status,
            posted_by: "alice".to_owned(),
            assigned_to: if status != TaskStatus::Open {
                Some("bob".to_owned())
            } else {
                None
            },
            posted_at: chrono::Utc::now(),
            claimed_at: None,
            plan: None,
            approved_by: None,
            approved_at: None,
            updated_at: None,
            notes: None,
            team: None,
            reviewer: None,
        };
        board.push(LiveTask::new(t));
    }

    #[test]
    fn handle_list_filters_terminal_tasks() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Claimed);
        seed_task(&plugin, "tb-003", TaskStatus::Finished);
        seed_task(&plugin, "tb-004", TaskStatus::Cancelled);

        let output = plugin.handle_list(false);
        assert!(output.contains("tb-001"), "open task should appear");
        assert!(output.contains("tb-002"), "claimed task should appear");
        assert!(!output.contains("tb-003"), "finished task should be hidden");
        assert!(
            !output.contains("tb-004"),
            "cancelled task should be hidden"
        );
    }

    #[test]
    fn handle_list_all_shows_everything() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Finished);
        seed_task(&plugin, "tb-003", TaskStatus::Cancelled);

        let output = plugin.handle_list(true);
        assert!(output.contains("tb-001"), "open task should appear");
        assert!(
            output.contains("tb-002"),
            "finished task should appear with all"
        );
        assert!(
            output.contains("tb-003"),
            "cancelled task should appear with all"
        );
    }

    #[test]
    fn handle_list_empty_after_filter() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Finished);
        seed_task(&plugin, "tb-002", TaskStatus::Cancelled);

        let output = plugin.handle_list(false);
        assert!(
            output.contains("no active tasks"),
            "should show helpful empty message, got: {output}"
        );
        assert!(
            output.contains("/taskboard list all"),
            "should hint at 'list all' command"
        );
    }

    // ── history tests ────────────────────────────────────────────────────

    #[test]
    fn handle_history_shows_finished_and_cancelled() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Claimed);
        seed_task(&plugin, "tb-003", TaskStatus::Finished);
        seed_task(&plugin, "tb-004", TaskStatus::Cancelled);

        let output = plugin.handle_history();
        assert!(!output.contains("tb-001"), "open task should not appear");
        assert!(!output.contains("tb-002"), "claimed task should not appear");
        assert!(output.contains("tb-003"), "finished task should appear");
        assert!(output.contains("tb-004"), "cancelled task should appear");
    }

    #[test]
    fn handle_history_empty_when_no_completed() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Claimed);

        let output = plugin.handle_history();
        assert!(
            output.contains("no completed tasks"),
            "should show empty message, got: {output}"
        );
    }

    #[test]
    fn handle_history_shows_assignee() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Finished);

        let output = plugin.handle_history();
        assert!(output.contains("bob"), "should show assignee");
        assert!(output.contains("ASSIGNEE"), "should have header");
    }

    // ── ABI entry point tests ────────────────────────────────────────────

    #[test]
    fn abi_declaration_matches_plugin() {
        let decl = &ROOM_PLUGIN_DECLARATION;
        assert_eq!(decl.api_version, room_protocol::plugin::PLUGIN_API_VERSION);
        unsafe {
            assert_eq!(decl.name().unwrap(), "taskboard");
            assert_eq!(decl.version().unwrap(), env!("CARGO_PKG_VERSION"));
            assert_eq!(decl.min_protocol().unwrap(), "0.0.0");
        }
    }

    #[test]
    fn abi_create_with_empty_config() {
        let plugin_ptr = unsafe { room_plugin_create(std::ptr::null(), 0) };
        assert!(!plugin_ptr.is_null());
        let plugin = unsafe { Box::from_raw(plugin_ptr) };
        assert_eq!(plugin.name(), "taskboard");
        assert_eq!(plugin.version(), env!("CARGO_PKG_VERSION"));
    }

    #[test]
    fn abi_create_with_json_config() {
        let tmp = tempfile::NamedTempFile::new().unwrap();
        let config = format!(
            r#"{{"storage_path":"{}","lease_ttl_secs":300}}"#,
            tmp.path().display()
        );
        let plugin_ptr = unsafe { room_plugin_create(config.as_ptr(), config.len()) };
        assert!(!plugin_ptr.is_null());
        let plugin = unsafe { Box::from_raw(plugin_ptr) };
        assert_eq!(plugin.name(), "taskboard");
    }

    #[test]
    fn abi_destroy_frees_plugin() {
        let plugin_ptr = unsafe { room_plugin_create(std::ptr::null(), 0) };
        assert!(!plugin_ptr.is_null());
        // Should not panic or double-free.
        unsafe { room_plugin_destroy(plugin_ptr) };
    }

    #[test]
    fn abi_destroy_null_is_safe() {
        // Passing null to destroy must be a no-op.
        unsafe { room_plugin_destroy(std::ptr::null_mut()) };
    }

    /// Multiple tasks with expired leases must all be swept in a single call,
    /// and Finished tasks must be left untouched even with a stale lease.
    #[test]
    fn sweep_expired_multiple_simultaneous_and_skips_finished() {
        let (plugin, _tmp) = make_plugin();

        // Seed 4 tasks: 3 Claimed (will expire) + 1 Finished (must survive).
        {
            let mut board = plugin.board.lock().unwrap();
            let stale = std::time::Instant::now() - std::time::Duration::from_secs(700);
            for i in 1..=3 {
                let t = task::Task {
                    id: format!("tb-{i:03}"),
                    description: format!("expiry test {i}"),
                    status: TaskStatus::Claimed,
                    posted_by: "alice".to_owned(),
                    assigned_to: Some(format!("agent-{i}")),
                    posted_at: chrono::Utc::now(),
                    claimed_at: Some(chrono::Utc::now()),
                    plan: None,
                    approved_by: None,
                    approved_at: None,
                    updated_at: None,
                    notes: None,
                    team: None,
                    reviewer: None,
                };
                let mut lt = LiveTask::new(t);
                lt.lease_start = Some(stale);
                board.push(lt);
            }
            // Finished task with a stale lease — must NOT be swept.
            let finished = task::Task {
                id: "tb-004".to_owned(),
                description: "finished task".to_owned(),
                status: TaskStatus::Finished,
                posted_by: "alice".to_owned(),
                assigned_to: Some("bob".to_owned()),
                posted_at: chrono::Utc::now(),
                claimed_at: Some(chrono::Utc::now()),
                plan: Some("done".to_owned()),
                approved_by: None,
                approved_at: None,
                updated_at: None,
                notes: None,
                team: None,
                reviewer: None,
            };
            let mut lt_finished = LiveTask::new(finished);
            // Manually inject stale lease to simulate edge case.
            lt_finished.lease_start = Some(stale);
            board.push(lt_finished);
        }

        let expired = plugin.sweep_expired();

        // All 3 Claimed tasks should have expired.
        assert_eq!(
            expired.len(),
            3,
            "expected 3 expired tasks, got {expired:?}"
        );
        for id in &expired {
            assert!(!id.contains("tb-004"), "Finished task must not be swept");
        }

        // Verify board state after sweep.
        let board = plugin.board.lock().unwrap();
        for lt in board.iter() {
            if lt.task.id == "tb-004" {
                assert_eq!(lt.task.status, TaskStatus::Finished);
                assert_eq!(lt.task.assigned_to.as_deref(), Some("bob"));
                assert_eq!(lt.task.plan.as_deref(), Some("done"));
            } else {
                assert_eq!(lt.task.status, TaskStatus::Open);
                assert!(lt.task.assigned_to.is_none());
                assert!(lt.lease_start.is_none());
            }
        }
    }

    /// When lease_ttl_secs is 0 (the default), sweep_expired must be a no-op
    /// even when tasks have stale lease timestamps.
    #[test]
    fn sweep_expired_disabled_when_ttl_zero() {
        let tmp = tempfile::NamedTempFile::new().unwrap();
        let plugin = TaskboardPlugin::new(tmp.path().to_path_buf(), None); // default = 0

        {
            let mut board = plugin.board.lock().unwrap();
            let stale = std::time::Instant::now() - std::time::Duration::from_secs(9999);
            let t = task::Task {
                id: "tb-001".to_owned(),
                description: "should not expire".to_owned(),
                status: TaskStatus::Claimed,
                posted_by: "alice".to_owned(),
                assigned_to: Some("bob".to_owned()),
                posted_at: chrono::Utc::now(),
                claimed_at: Some(chrono::Utc::now()),
                plan: None,
                approved_by: None,
                approved_at: None,
                updated_at: None,
                notes: None,
                team: None,
                reviewer: None,
            };
            let mut lt = LiveTask::new(t);
            lt.lease_start = Some(stale);
            board.push(lt);
        }

        let expired = plugin.sweep_expired();
        assert!(expired.is_empty(), "TTL=0 must disable expiry");

        let board = plugin.board.lock().unwrap();
        assert_eq!(board[0].task.status, TaskStatus::Claimed);
        assert_eq!(board[0].task.assigned_to.as_deref(), Some("bob"));
    }

    // ── handle_mine tests ────────────────────────────────────────────────

    #[test]
    fn handle_mine_returns_only_assigned_tasks() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Claimed); // assigned to "bob"
        seed_task(&plugin, "tb-003", TaskStatus::InProgress); // assigned to "bob"

        // Seed one task assigned to "alice".
        {
            let mut board = plugin.board.lock().unwrap();
            let t = task::Task {
                id: "tb-004".to_owned(),
                description: "alice task".to_owned(),
                status: TaskStatus::Claimed,
                posted_by: "manager".to_owned(),
                assigned_to: Some("alice".to_owned()),
                posted_at: chrono::Utc::now(),
                claimed_at: None,
                plan: None,
                approved_by: None,
                approved_at: None,
                updated_at: None,
                notes: None,
                team: None,
                reviewer: None,
            };
            board.push(LiveTask::new(t));
        }

        let output = plugin.handle_mine("bob");
        assert!(
            output.contains("tb-002"),
            "bob's claimed task should appear"
        );
        assert!(
            output.contains("tb-003"),
            "bob's approved task should appear"
        );
        assert!(
            !output.contains("tb-001"),
            "unassigned task should not appear"
        );
        assert!(
            !output.contains("tb-004"),
            "alice's task should not appear for bob"
        );
    }

    #[test]
    fn handle_mine_empty_when_no_tasks_assigned() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Claimed); // assigned to "bob"

        let output = plugin.handle_mine("alice");
        assert!(
            output.contains("no tasks assigned to alice"),
            "should show empty message, got: {output}"
        );
    }

    #[test]
    fn handle_mine_includes_finished_tasks() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Finished); // assigned to "bob"

        let output = plugin.handle_mine("bob");
        assert!(
            output.contains("tb-001"),
            "finished tasks should appear in mine"
        );
    }

    // ── qa-queue tests ──────────────────────────────────────────────────

    #[test]
    fn handle_qa_queue_returns_only_awaiting_review() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Claimed);
        seed_task(&plugin, "tb-003", TaskStatus::AwaitingReview);
        seed_task(&plugin, "tb-004", TaskStatus::Finished);

        let output = plugin.handle_qa_queue();
        assert!(
            output.contains("tb-003"),
            "AwaitingReview task should appear"
        );
        assert!(!output.contains("tb-001"), "open task should not appear");
        assert!(!output.contains("tb-002"), "claimed task should not appear");
        assert!(
            !output.contains("tb-004"),
            "finished task should not appear"
        );
    }

    #[test]
    fn handle_qa_queue_empty_when_none_awaiting() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::Open);
        seed_task(&plugin, "tb-002", TaskStatus::Claimed);
        seed_task(&plugin, "tb-003", TaskStatus::Finished);

        let output = plugin.handle_qa_queue();
        assert!(
            output.contains("no tasks awaiting review"),
            "should show empty message, got: {output}"
        );
    }

    #[test]
    fn handle_qa_queue_shows_assignee_and_header() {
        let (plugin, _tmp) = make_plugin();
        seed_task(&plugin, "tb-001", TaskStatus::AwaitingReview);

        let output = plugin.handle_qa_queue();
        assert!(output.contains("bob"), "should show assignee");
        assert!(output.contains("ASSIGNEE"), "should have header");
        assert!(output.contains("ID"), "should have ID header");
    }
}