kasl/libs/messages/

display.rs

//! Display implementation for kasl application messages.
//!
//! Provides the core `Display` trait implementation for the `Message` enum, enabling automatic conversion of structured message data into human-readable text.
//!
//! ## Usage
//!
//! ```rust
//! use kasl::libs::messages::types::Message;
//!
//! let message = Message::TaskCreated;
//! println!("{}", message);
//!
//! let parameterized = Message::MonitorStarted {
//!     pause_threshold: 60,
//!     poll_interval: 500,
//!     activity_threshold: 30,
//! };
//! println!("{}", parameterized);
//! ```

use super::types::Message;
use std::fmt::{Display, Formatter, Result};

impl Display for Message {
    /// Converts a `Message` enum variant into human-readable text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use kasl::libs::messages::Message;
    ///
    /// // Automatic formatting through Display trait
    /// let message = Message::TaskCreated;
    /// println!("{}", message); // "Task created successfully"
    ///
    /// // With parameters
    /// let date_message = Message::WorkdayStarting("2025-01-15".to_string());
    /// println!("{}", date_message); // "Starting workday for 2025-01-15"
    /// ```
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        let text = match self {
            // === AUTOSTART MESSAGES ===
            Message::AutostartEnabled => "Autostart has been enabled. Kasl will start automatically on system boot.".to_string(),
            Message::AutostartEnabledUser => "Autostart has been enabled for current user. Kasl will start when you log in.".to_string(),
            Message::AutostartDisabled => "Autostart has been disabled.".to_string(),
            Message::AutostartAlreadyDisabled => "Autostart was already disabled.".to_string(),
            Message::AutostartEnableFailed(error) => format!("Failed to enable autostart: {}", error),
            Message::AutostartDisableFailed(error) => format!("Failed to disable autostart: {}", error),
            Message::AutostartStatus(status) => format!("Autostart is currently: {}", status),
            Message::AutostartRequiresAdmin => "Administrator privileges required for system-level autostart. Trying user-level alternative...".to_string(),
            Message::AutostartCheckingAlternative => "Checking alternative autostart method...".to_string(),

            // === TASK MESSAGES ===
            Message::TaskCreated => "Task created successfully".to_string(),
            Message::TaskUpdated => "Task updated successfully".to_string(),
            Message::TaskNotFound => "Task not found".to_string(),
            Message::TaskUpdateFailed => "Failed to update task".to_string(),
            Message::TasksDeletedCount(count) => format!("Deleted {} task(s) successfully.", count),
            Message::TasksNotFoundForDate(date) => format!("Tasks not found for {}, report not sent.", date),
            Message::TasksNotFoundSad => "No tasks found.".to_string(),
            Message::TasksHeader => "Tasks:".to_string(),
            Message::TasksDiscoverySummary { incomplete, jira, gitlab } => {
                let mut parts = Vec::new();
                if *incomplete > 0 {
                    parts.push(format!("{} incomplete", incomplete));
                }
                if *jira > 0 {
                    parts.push(format!("{} jira", jira));
                }
                if *gitlab > 0 {
                    parts.push(format!("{} gitlab", gitlab));
                }
                format!("Found: {}", parts.join(", "))
            }
            Message::TasksDiscoverySeparator => "──────── other ────────".to_string(),
            Message::TasksDiscoverySearchingIncomplete => "Looking for incomplete tasks...".to_string(),
            Message::TasksDiscoveryFetchingExternal => "Fetching GitLab commits and Jira issues...".to_string(),
            Message::NoTaskIdsProvided => "No task IDs provided for deletion.".to_string(),
            Message::TasksNotFoundForIds(ids) => format!("No tasks found with IDs: {:?}", ids),
            Message::TasksToBeDeleted => "The following tasks will be deleted:".to_string(),
            Message::ConfirmDeleteTask => "Are you sure you want to delete this task?".to_string(),
            Message::ConfirmDeleteTasks(count) => format!("Are you sure you want to delete {} tasks?", count),
            Message::ConfirmDeleteAllTodayTasks(count) => format!("Are you sure you want to delete ALL {} tasks for today?", count),
            Message::ConfirmDeleteAllTodayTasksFinal => "This action cannot be undone. Are you REALLY sure?".to_string(),
            Message::NoTasksForToday => "No tasks found for today.".to_string(),
            Message::TaskNotFoundWithId(id) => format!("Task with ID {} not found.", id),
            Message::CurrentTaskState => "Current task:".to_string(),
            Message::TaskEditPreview => "Task after changes:".to_string(),
            Message::ConfirmTaskUpdate => "Save changes?".to_string(),
            Message::NoChangesDetected => "No changes detected.".to_string(),
            Message::NoTasksSelected => "No tasks selected for editing.".to_string(),
            Message::SelectTasksToEdit => "Select tasks to edit (space to select, enter to confirm)".to_string(),
            Message::EditingTask(name) => format!("Editing task: {}", name),
            Message::TaskUpdatedWithName(name) => format!("Task '{}' updated successfully.", name),
            Message::TaskSkippedNoChanges(name) => format!("Task '{}' - no changes, skipped.", name),
            Message::TaskEditingCompleted => "Task editing completed.".to_string(),
            Message::PromptTaskNameEdit => "Task name".to_string(),
            Message::PromptTaskCommentEdit => "Comment (optional)".to_string(),
            Message::PromptTaskCompletenessEdit => "Completeness (0-100)".to_string(),
            Message::TaskCompletenessRange => "Completeness must be between 0 and 100".to_string(),

            // === WORKDAY MESSAGES ===
            Message::WorkdayEnded => "Workday ended for today.".to_string(),
            Message::WorkdayNeverStarted(date) => {
                format!(
                    "No workday was started on {}, so there is nothing to end. `kasl watch` opens the day, and `kasl report` shows what is recorded.",
                    date
                )
            }
            Message::WorkdayNotFoundForDate(date) => format!("No workday record found for {}", date),
            Message::WorkdayCreateFailed => "Failed to create workday".to_string(),
            Message::WorkdayStarting(date) => format!("Starting workday for {}", date),
            Message::WorkdayCouldNotFindAfterFinalizing(date) => {
                format!("Could not find workday for {} after finalizing.", date)
            }

            // === CONFIGURATION MESSAGES ===
            Message::ConfigSaved => "Configuration saved successfully".to_string(),
            Message::ConfigDeleted => "Configuration deleted successfully".to_string(),
            Message::ConfigParseError => "Failed to parse configuration".to_string(),
            Message::ConfigSaveError => "Failed to save configuration".to_string(),
            Message::ConfigModuleGitLab => "GitLab settings".to_string(),
            Message::ConfigModuleJira => "Jira settings".to_string(),
            Message::ConfigModuleSiServer => "SiServer settings".to_string(),
            Message::ConfigModuleMonitor => "Monitor settings".to_string(),
            Message::ConfigModuleServer => "Server settings".to_string(),
            Message::ConfigModuleProductivity => "Productivity settings".to_string(),
            Message::ConfigModuleTaskDiscovery => "Task discovery settings".to_string(),
            Message::ConfigModuleJiraInbox => "Jira inbox settings".to_string(),
            Message::TaskDiscoveryIgnoreListHeader => "Current ignore list:".to_string(),
            Message::TaskDiscoveryIgnoreListEmpty => "Ignore list is empty.".to_string(),
            Message::TaskDiscoveryIgnoreNameAdded(name) => format!("Added '{}' to ignore list.", name),
            Message::TaskDiscoveryIgnoreNameExists(name) => format!("'{}' is already in the ignore list.", name),
            Message::TaskDiscoveryIgnoreNamesAdded(count) => {
                format!("Added {} name(s) to the discovery ignore list.", count)
            }

            // === REPORT MESSAGES ===
            Message::DailyReportSent(date) => {
                format!(
                    "Your report dated {} has been successfully submitted\nWait for a message to your email address",
                    date
                )
            }
            Message::MonthlyReportSent(date) => {
                format!(
                    "Your monthly report dated {} has been successfully submitted\nWait for a message to your email address",
                    date
                )
            }
            Message::MonthlyReportTriggered => "It's the last working day of the month. Submitting the monthly report as well...".to_string(),
            Message::ReportSendFailed(status) => format!("Failed to send report. Status: {}", status),
            Message::MonthlyReportSendFailed(status) => format!("Failed to send monthly report. Status: {}", status),
            Message::ReportHeader(date) => format!("Report for {}", date),
            Message::WorkingHoursForMonth(month_year) => format!("Working hours for {}", month_year),
            Message::ReportPayloadHeading { url, date } => {
                format!("This is what {} would send to {}, as a multipart form:", date, url)
            }

            // === EXPORT MESSAGES ===
            Message::ExportingData(data, format) => format!("Exporting {} in {} format...", data, format),
            Message::ExportCompleted(path) => format!("Export completed successfully: {}", path),
            Message::ExportingAllData => "Exporting all data...".to_string(),

            // === TEMPLATE MESSAGES ===
            Message::TemplateCreated(name) => format!("Template '{}' created successfully.", name),
            Message::TemplateUpdated(name) => format!("Template '{}' updated successfully.", name),
            Message::TemplateDeleted(name) => format!("Template '{}' deleted successfully.", name),
            Message::TemplateNotFound(name) => format!("Template '{}' not found.", name),
            Message::TemplateAlreadyExists(name) => format!("Template '{}' already exists.", name),
            Message::TemplateCreateFailed => "Failed to create template.".to_string(),
            Message::NoTemplatesFound => "No templates found.".to_string(),
            Message::TemplateListHeader => "Task Templates:".to_string(),
            Message::SelectTemplateToEdit => "Select template to edit".to_string(),
            Message::SelectTemplateToDelete => "Select template to delete".to_string(),
            Message::ConfirmDeleteTemplate(name) => format!("Delete template '{}'?", name),
            Message::EditingTemplate(name) => format!("Editing template: {}", name),
            Message::NoTemplatesMatchingQuery(query) => format!("No templates matching '{}'", query),
            Message::TemplateSearchResults(query) => format!("Templates matching '{}':", query),
            Message::SelectTemplateAction => "What would you like to do?".to_string(),
            Message::PromptTemplateName => "Template name (unique identifier)".to_string(),
            Message::PromptTemplateTaskName => "Task name".to_string(),
            Message::PromptTemplateComment => "Comment (optional)".to_string(),
            Message::PromptTemplateCompleteness => "Default completeness (0-100)".to_string(),
            Message::CreatingTaskFromTemplate(name) => format!("Creating task from template '{}'", name),
            Message::SelectTemplate => "Select a template".to_string(),
            Message::CreateTemplateFirst => "Create templates with 'kasl template add'".to_string(),

            // === TAG MESSAGES ===
            Message::TagCreated(name) => format!("Tag '{}' created successfully.", name),
            Message::TagUpdated(name) => format!("Tag '{}' updated successfully.", name),
            Message::TagDeleted(name) => format!("Tag '{}' deleted successfully.", name),
            Message::TagNotFound(name) => format!("Tag '{}' not found.", name),
            Message::TagAlreadyExists(name) => format!("Tag '{}' already exists.", name),
            Message::NoTagsFound => "No tags found.".to_string(),
            Message::TagListHeader => "Tags:".to_string(),
            Message::EditingTag(name) => format!("Editing tag: {}", name),
            Message::SelectTagAction => "What would you like to do?".to_string(),
            Message::SelectTagToEdit => "Select tag to edit".to_string(),
            Message::SelectTagToDelete => "Select tag to delete".to_string(),
            Message::ConfirmDeleteTag(name) => format!("Delete tag '{}'?", name),
            Message::ConfirmDeleteTagWithTasks(name, count) => format!("Tag '{}' is used by {} task(s). Delete anyway?", name, count),
            Message::PromptTagName => "Tag name".to_string(),
            Message::PromptTagColor => "Tag color (e.g., blue, green, red)".to_string(),
            Message::NoTasksWithTag(tag) => format!("No tasks found with tag '{}'.", tag),
            Message::TasksWithTag(tag) => format!("Tasks with tag '{}':", tag),
            Message::TagsAddedToTask(tags) => format!("Tags added: {}", tags),

            // === SHORT INTERVALS MESSAGES ===
            Message::ShortIntervalsDetected(count, duration) => format!("Found {} short work intervals (total: {})", count, duration),
            Message::PromptMinWorkInterval => "Minimum work interval (minutes)".to_string(),

            // === TIME ADJUSTMENT MESSAGES ===
            Message::WorkdayUpdateFailed => "Failed to update workday.".to_string(),

            // === PAUSE MESSAGES ===
            Message::PausesTitle(date) => format!("Pauses for {}", date),

            // === MONITOR MESSAGES ===
            Message::MonitorStarted {
                pause_threshold,
                poll_interval,
                activity_threshold,
            } => {
                format!(
                    "Monitor is running with pause threshold {}s, poll interval {}ms, activity threshold {}s",
                    pause_threshold, poll_interval, activity_threshold
                )
            }
            Message::MonitorExitedNormally => "Monitor exited normally".to_string(),
            Message::MonitorShuttingDown => "Shutting down monitor...".to_string(),
            Message::MonitorError(error) => format!("Monitor error: {}", error),
            Message::MonitorTaskPanicked(error) => format!("Monitor task panicked: {}", error),
            Message::PauseStarted => "Pause Start".to_string(),
            Message::PauseEnded => "Pause End".to_string(),

            // === WATCHER/DAEMON MESSAGES ===
            Message::WatcherStarted(pid) => format!("Watcher started in the background (PID: {}).", pid),
            Message::WatcherStopped(pid) => format!("Watcher process (PID: {}) stopped successfully.", pid),
            Message::WatcherNotRunning => "Watcher is not running.".to_string(),
            Message::WatcherNotRunningPidNotFound => "Watcher does not appear to be running (PID file not found).".to_string(),
            Message::WatcherStartingForeground => "Starting watcher in foreground... Press Ctrl+C to exit.".to_string(),
            Message::WatcherAlreadyRunningPid(pid) => format!("A watcher is already running (PID: {}) - left it as it is.", pid),
            Message::WatcherAlreadyRunning => "A watcher is already running for this user - stop it with `kasl watch --stop`, then run this again.".to_string(),
            Message::WatcherStoppingExisting(pid) => format!("Stopping existing watcher (PID: {})...", pid),
            Message::WatcherFailedToStopExisting(error) => format!("Warning: Failed to stop existing daemon: {}", error),
            Message::WatcherReceivedSigterm => "Received SIGTERM, shutting down gracefully...".to_string(),
            Message::WatcherReceivedSigint => "Received SIGINT, shutting down gracefully...".to_string(),
            Message::WatcherReceivedCtrlC => "Received Ctrl+C, shutting down gracefully...".to_string(),
            Message::WatcherCtrlCListenFailed(error) => format!("Failed to listen for Ctrl+C: {}", error),
            Message::WatcherSignalHandlingNotSupported => "Warning: Signal handling not supported on this platform".to_string(),
            Message::DaemonModeNotSupported => "Daemon mode is not supported on this platform.".to_string(),
            Message::FailedToGetCurrentExecutable => "Failed to get the path of the current executable".to_string(),
            Message::FailedToCreateSigtermHandler => "Failed to create SIGTERM handler".to_string(),
            Message::FailedToCreateSigintHandler => "Failed to create SIGINT handler".to_string(),

            // === UPDATE MESSAGES ===
            Message::UpdateAvailable { app_name, latest } => {
                format!(
                    "A new version of {} is available: v{}\nUpgrade now by running: {} self-update",
                    app_name, latest, app_name
                )
            }
            Message::UpdateCompleted { app_name, version } => {
                format!("The {} application has been successfully updated to version {}!", app_name, version)
            }
            Message::NoUpdateRequired => "No update required. You are using the latest version!".to_string(),
            Message::UpdateDownloadUrlNotSet => "Download URL not set".to_string(),
            Message::UpdateLatestTagNotFound(url) => format!("Could not resolve the latest release tag from {}", url),
            Message::WatcherStoppingForUpdate => "Stopping watcher for update...".to_string(),
            Message::WatcherRestartingAfterUpdate => "Restarting watcher after update...".to_string(),
            Message::WatcherStoppingForConfig => "Stopping watcher to apply new configuration...".to_string(),
            Message::WatcherRestartingAfterConfig => "Restarting watcher with updated configuration...".to_string(),
            Message::WatcherRestarted => "Watcher successfully restarted with new configuration".to_string(),
            Message::WatcherRestartFailed { error } => format!("Warning: Failed to restart watcher: {}", error),
            Message::UpdateBinaryNotFoundInArchive => "Binary not found in the release archive.".to_string(),

            // === AUTHENTICATION MESSAGES ===
            Message::WrongPassword(count) => format!("You entered the wrong password {} times!", count),

            // === API MESSAGES ===
            Message::GitlabFetchFailed(error) => format!("[kasl] Failed to get GitLab events: {}", error),
            Message::GitlabUserIdFailed(error) => format!("[kasl] Failed to get GitLab user ID: {}", error),
            Message::JiraFetchFailed(error) => format!("[kasl] Failed to get Jira issues: {}", error),
            Message::SiServerConfigNotFound => "SiServer configuration not found in config file.".to_string(),
            Message::SiServerSessionFailed(error) => format!("[kasl] Failed to get SiServer session for rest dates: {}", error),
            Message::SiServerRestDatesFailed(error) => format!("[kasl] Failed to request rest dates: {}", error),
            Message::SiServerRestDatesParsingFailed(error) => format!("[kasl] Failed to parse rest dates response: {}", error),

            // === KASL-SERVER MESSAGES ===
            Message::KaslServerReached { url, version } => format!("{} is kasl-server {}", url, version),
            Message::KaslServerConnected { user_name, agent_name } => {
                format!("Connected as {} (agent '{}')", user_name, agent_name)
            }
            Message::KaslServerConfigured(url) => format!("Configured server: {}", url),
            Message::KaslServerDatabaseUnhealthy(state) => {
                format!(
                    "The server answered, but reports its database as '{}' - uploads will fail until that clears.",
                    state
                )
            }
            Message::KaslServerUnreachable(error) => format!("Cannot reach the server: {}", error),
            Message::KaslServerTokenRejected(error) => format!("The stored token no longer works: {}", error),
            Message::KaslServerUrlNeedsScheme(url) => {
                format!(
                    "'{}' has no scheme - write http:// or https:// so it is clear whether the token crosses the network in the clear.",
                    url
                )
            }
            Message::KaslServerTokenEmpty => "No token entered; nothing was changed.".to_string(),
            Message::KaslServerTokenMissing => "A server is configured but no token is stored - run `kasl server connect` again.".to_string(),
            Message::KaslServerTokenNotRemoved(error) => {
                format!("The address was forgotten, but the stored token could not be removed: {}", error)
            }
            Message::KaslServerNotConnected => "This machine is not connected to a kasl-server.".to_string(),
            Message::KaslServerDisconnected => "Disconnected; the stored token has been removed.".to_string(),
            Message::KaslServerNoDayToPush(date) => format!("No workday recorded for {} - nothing to send.", date),
            Message::KaslServerDayPushed { date, pauses, tasks } => {
                format!("Sent {} to the server: {} pauses, {} tasks", date, pauses, tasks)
            }
            Message::KaslServerTasksDeleted(count) => {
                format!("{} task(s) removed on the server - deleted here since the last upload", count)
            }
            Message::KaslServerPushRejected(error) => {
                format!(
                    "{}
The server will not accept this day as sent; fix it here and push again.",
                    error
                )
            }
            Message::KaslServerPushTokenRejected(error) => {
                format!(
                    "{}
Run `kasl server connect` to connect again with a token your administrator issues.",
                    error
                )
            }
            Message::KaslServerDayQueued(date) => {
                format!("{} is queued and will be sent with the next successful push.", date)
            }
            Message::KaslServerQueueEmpty => "Nothing is waiting to be sent.".to_string(),
            Message::KaslServerQueueOwed(count) => match count {
                1 => "1 day is waiting to be sent:".to_string(),
                _ => format!("{} days are waiting to be sent:", count),
            },
            Message::KaslServerQueueEntry { date, attempts, last_error } => {
                // The attempt count and the last reason are the answer to
                // "why is this one still here", which is otherwise invisible.
                let tried = match attempts {
                    1 => "1 attempt".to_string(),
                    _ => format!("{} attempts", attempts),
                };
                match last_error {
                    Some(error) => format!("  {} - {}, last: {}", date, tried, error),
                    None => format!("  {} - {}", date, tried),
                }
            }
            Message::KaslServerQueueSending(count) => match count {
                1 => "Sending 1 day...".to_string(),
                _ => format!("Sending {} days...", count),
            },
            Message::KaslServerDayRefused { date, reason } => {
                format!("{} was refused and has been dropped from the queue: {}", date, reason)
            }
            Message::KaslServerDayDeferred { date, reason } => {
                format!("{} is still waiting: {}", date, reason)
            }
            Message::KaslServerFlushSummary { accepted, refused, deferred } => {
                format!("{} sent, {} refused, {} still waiting", accepted, refused, deferred)
            }
            Message::KaslServerBackfillRange { from, to, days } => match days {
                1 => format!("1 recorded day between {} and {}", from, to),
                _ => format!("{} recorded days between {} and {}", days, from, to),
            },
            Message::KaslServerBackfillNoDays { from, to } => {
                format!("No workdays recorded between {} and {} - nothing to send.", from, to)
            }
            Message::KaslServerBackfillOrderReversed => "The start of the range is after its end; swap --from and --to.".to_string(),
            Message::KaslServerBackfillWholeHistory { from, to, days } => match days {
                1 => format!("1 recorded day, the whole history from {} to {}", from, to),
                _ => format!("{} recorded days, the whole history from {} to {}", days, from, to),
            },
            Message::KaslServerBackfillNothingRecorded => "No workday has ever been recorded on this machine - nothing to send.".to_string(),
            Message::KaslServerCompatibility { server_version, api_version } => {
                format!("server {} · api {} · ok", server_version, api_version)
            }
            Message::KaslServerPrivacyHeading(level) => format!("Privacy level on this server: {}", level),
            Message::KaslServerPrivacySummary(summary) => summary.clone(),
            Message::KaslServerPrivacyStoredHeading => "What it stores:".to_string(),
            Message::KaslServerPrivacyStored { what, detail } => format!("  {} - {}", what, detail),
            Message::KaslServerPrivacyNeverHeading => "What it never collects:".to_string(),
            Message::KaslServerPrivacyBullet(line) => format!("  {}", line),
            Message::KaslServerPrivacyVisibleHeading => "Who can see it:".to_string(),
            Message::KaslServerPrivacyRetention(text) => format!("Retention: {}", text),
            Message::KaslServerPrivacyOnChange(text) => format!("If the level changes: {}", text),
            Message::KaslServerPrivacyUpdatedAt(when) => format!("This level was last set {}.", when),
            Message::KaslServerPrivacySetByAdmin => {
                "The level is the installation's, set by an administrator on the server. kasl shows it; it cannot widen or narrow it from here.".to_string()
            }
            // === PULSE MESSAGES ===
            Message::PulseOff => "Pulse: off - the server is not told whether you are working right now. `kasl server pulse enable` turns it on.".to_string(),
            Message::PulseNothingYet => {
                "Pulse: on - nothing has been sent since it was turned on. A running watcher sends one within seconds; `kasl watch` starts one.".to_string()
            }
            Message::PulseLastSent { ago, state } => match state {
                Some(state) => format!("Pulse: on - the last one went {} ago ({}).", ago, state),
                None => format!("Pulse: on - the last one went {} ago.", ago),
            },
            Message::PulseFailing { ago, error } => format!("Pulse: on, but the last one ({} ago) did not arrive: {}", ago, error),
            Message::PulseLastArrived(ago) => format!("The last one that arrived went {} ago.", ago),
            Message::PulseSilent(ago) => format!(
                "The watcher was due to send another {} ago and has not - it is not running, or has stopped. `kasl watch` starts it.",
                ago
            ),
            Message::PulseShownOffline(stale_after) => {
                format!("The server stops believing a pulse after {}, so it now shows you as offline.", stale_after)
            }
            Message::PulseClockSkew(seconds) => format!(
                "This machine's clock is {} s {} the server's - every time it records is off by as much, and the server refuses a pulse stamped more than a minute ahead. Set the clock right.",
                seconds.abs(),
                if *seconds > 0 { "ahead of" } else { "behind" }
            ),
            Message::PulseEnabled(url) => format!(
                "Pulse on: the watcher tells {} once a minute whether you are working, on a break, or not in a day - the state only, never the task or the reason for a break.",
                url
            ),
            Message::PulseNoWatcher => "No background watcher is running, so nothing goes out until one starts - `kasl watch`.".to_string(),
            Message::PulseFirstArrived(state) => format!("The first pulse arrived: the server shows you as {}.", state),
            Message::PulseFirstFailed(error) => format!(
                "The first pulse did not arrive: {}
The watcher keeps trying; `kasl server status` shows how it goes.",
                error
            ),
            Message::PulseFirstPending => "The watcher has not sent one yet; `kasl server status` shows when it does.".to_string(),
            Message::PulseDisabled(stale_after) => match stale_after {
                Some(stale_after) => format!(
                    "Pulse off. The server keeps the last state it received, and shows you as offline once that is {} old.",
                    stale_after
                ),
                None => "Pulse off. The server keeps the last state it received, and shows you as offline once it stops believing it.".to_string(),
            },
            Message::PulseAlreadyOff => "The pulse is already off.".to_string(),
            Message::KaslServerPushRetryable(error) => {
                format!(
                    "{}
The day is unchanged here and stays queued - `kasl server flush` sends it when the server is back.",
                    error
                )
            }

            // === DATABASE MESSAGES ===
            Message::DatabaseOperationFailed { operation, error } => {
                format!("Database operation '{}' failed (continuing monitoring): {}", operation, error)
            }
            Message::NoIdSet => "No ID set".to_string(),

            // === FILE SYSTEM MESSAGES ===
            Message::FileNotFound => "File not found".to_string(),
            Message::InvalidPidFileContent => "Invalid PID file content".to_string(),

            // === SYSTEM/PATH MESSAGES ===
            Message::PathConfigured => "PATH successfully configured for system-wide access".to_string(),
            Message::PathConfigWarning { error } => format!(
                "Warning: Could not configure PATH automatically. {}\nYou may need to run as administrator or manually add kasl to your PATH.",
                error
            ),
            Message::PathRegistryQueryError { status } => format!("Registry query failed (exit code: {})", status),
            Message::PathRegistryUpdateError { status, stderr } => {
                if stderr.trim().is_empty() {
                    format!("Registry update failed (exit code: {})", status)
                } else {
                    format!("Registry update failed (exit code: {}): {}", status, stderr.trim())
                }
            }
            Message::FailedToJoinPaths => "Failed to join paths".to_string(),
            Message::FailedToExecuteRegQuery => "Failed to execute reg query".to_string(),
            Message::FailedToParseRegOutput => "Failed to parse reg query output".to_string(),
            Message::FailedToGetPathFromReg => "Failed to get PATH value from reg query".to_string(),
            Message::FailedToExecuteRegSet => "Failed to execute reg set".to_string(),
            Message::FailedToOpenProcess(code) => format!("Failed to open process: error code {}", code),
            Message::FailedToTerminateProcess(code) => format!("Failed to terminate process: error code {}", code),
            Message::ProcessTerminationNotSupported => "Process termination not supported on this platform".to_string(),

            // === PRODUCTIVITY MESSAGES ===
            Message::MonthlyProductivity(percentage) => format!("Monthly work productivity: {:.1}%", percentage),
            Message::LowProductivityWarning { current, threshold } => {
                format!(
                    "🔴 LOW PRODUCTIVITY: {:.1}% (minimum: {:.1}%)\n   If an absence is missing from the day, record it: kasl pauses add --start HH:MM --minutes N",
                    current, threshold
                )
            }
            Message::ProductivityTooLowToSend { current, threshold } => {
                format!(
                    "Cannot send report: productivity {:.1}% is below minimum {:.1}%\nIf an absence is missing from the day, record it: kasl pauses add --start HH:MM --minutes N",
                    current, threshold
                )
            }
            Message::ManualPauseCreated {
                start_time,
                end_time,
                duration_minutes,
            } => {
                format!("Pause recorded: {} - {} ({} minutes)", start_time, end_time, duration_minutes)
            }
            Message::ManualPauseOverlaps { start_time, end_time } => {
                format!("Overlaps an existing pause ({} - {})", start_time, end_time)
            }
            Message::ManualPauseRemoved(id) => format!("Pause {} removed", id),
            Message::ManualPauseNotFound(id) => format!("no pause with id '{}' - see `kasl pauses list`", id),

            // === ENCRYPTION/SECRET MESSAGES ===

            // === PROMPTS ===
            Message::PromptTaskName => "Enter task name (multi-line paste OK)".to_string(),
            Message::TaskNameMergedFromPaste => "Merged pasted lines into the task name.".to_string(),
            Message::PromptTaskComment => "Enter comment".to_string(),
            Message::PromptTaskCompleteness => "Enter completeness".to_string(),
            Message::PromptMinPauseDuration => "Enter minimum pause duration (minutes)".to_string(),
            Message::PromptPauseThreshold => "Enter pause threshold (seconds)".to_string(),
            Message::PromptPollInterval => "Enter poll interval (milliseconds)".to_string(),
            Message::PromptActivityThreshold => "Enter activity threshold (seconds)".to_string(),
            Message::PromptMinProductivityThreshold => "Enter minimum productivity threshold (%)".to_string(),
            Message::PromptWorkdayHours => "Enter expected workday duration (hours)".to_string(),
            Message::PromptMinWorkdayFraction => "Enter minimum workday fraction before suggesting breaks (0.0-1.0)".to_string(),
            Message::PromptServerApiUrl => "Enter server API URL".to_string(),
            Message::PromptServerAuthToken => "Enter server auth token".to_string(),
            Message::PromptKaslServerUrl => "kasl-server URL".to_string(),
            Message::PromptKaslServerToken => "Agent token (issued by your administrator)".to_string(),
            Message::PromptSelectModules => "Select nodes to configure".to_string(),
            Message::PromptSelectTasksToImport => "Select tasks to import".to_string(),
            Message::PromptSelectTasksToIgnore => "Select tasks to ignore (optional)".to_string(),
            Message::PromptSelectIgnoreNamesToRemove => "Select ignore names to remove (optional)".to_string(),
            Message::PromptAddIgnoreName => "Add ignore name (empty to finish)".to_string(),

            // === GENERAL MESSAGES ===
            Message::OperationCompleted => "Operation completed successfully".to_string(),
            Message::OperationCancelled => "Operation cancelled".to_string(),
            Message::InvalidInput => "Invalid input provided".to_string(),
            Message::PermissionDenied => "Permission denied".to_string(),
            Message::DeprecatedCommand(old, new) => {
                format!("`kasl {}` is now `kasl {}`. The old name still works but will be removed in 2.0.", old, new)
            }

            // === ERROR LOGGING ===
            Message::ErrorSendingEvents(error) => format!("[kasl] Error sending events: {}", error),
            Message::ErrorSendingMonthlyReport(error) => format!("[kasl] Error sending monthly report: {}", error),
            Message::ErrorInRdevListener(error) => format!("Error in rdev listener: {:?}", error),
            Message::ErrorRequestingRestDates(error) => format!("Error requesting rest dates: {}", error),

            // === SPECIFIC UI MESSAGES ===
            Message::SelectingTask(name) => format!("Selected task: {}", name),

            // === JIRA INBOX MESSAGES ===
            Message::JiraInboxRequiresJiraConfig => "Jira inbox requires Jira to be configured. Run `kasl setup` and select Jira.".to_string(),
            Message::JiraInboxEmpty => "Jira inbox is empty.".to_string(),
            Message::JiraInboxListHeader => "Jira inbox:".to_string(),
            Message::JiraInboxListSliced { shown, total, what } => {
                if what.is_empty() {
                    format!("Jira inbox: {} of {} issues:", shown, total)
                } else {
                    format!("Jira inbox: {} of {} issues ({}):", shown, total, what)
                }
            }
            Message::JiraInboxNoMatch { total, what } => format!("No issue matches ({}); {} in the inbox.", what, total),
            Message::JiraInboxSynced {
                fetched,
                new_count,
                changed,
                gone,
            } => {
                format!("Jira inbox synced: {} fetched, {} new, {} changed, {} gone.", fetched, new_count, changed, gone)
            }
            Message::JiraInboxNewIssues(count) => format!("Jira inbox: {} new issue(s).", count),
            Message::JiraInboxNotFound(key) => format!("Issue '{}' not found in inbox.", key),
            Message::JiraInboxPinned(key) => format!("Pinned {}.", key),
            Message::JiraInboxUnpinned(key) => format!("Unpinned {}.", key),
            Message::JiraInboxDismissed(key) => format!("Dismissed {}.", key),
            Message::JiraInboxUndismissed(key) => format!("{} is back in the inbox.", key),
            Message::JiraInboxSnoozed(key, until) => format!("Snoozed {} until {}.", key, until),
            Message::JiraInboxUnsnoozed(key) => format!("Woke {}.", key),
            Message::JiraInboxAllSnoozed(count) => {
                format!("Jira inbox is clear; {} issue(s) are snoozed. `kasl inbox --snoozed` shows them.", count)
            }
            Message::JiraInboxWoke(count) => format!("Jira inbox: {} snoozed issue(s) came back.", count),
            Message::JiraInboxTriaged {
                taken,
                snoozed,
                dismissed,
                skipped,
                left,
            } => {
                // Only what happened: a run of twenty skips should not read as
                // a wall of zeroes about things that did not.
                let mut parts = Vec::new();
                if *taken > 0 {
                    parts.push(format!("{} taken", taken));
                }
                if *snoozed > 0 {
                    parts.push(format!("{} snoozed", snoozed));
                }
                if *dismissed > 0 {
                    parts.push(format!("{} dismissed", dismissed));
                }
                if *skipped > 0 {
                    parts.push(format!("{} skipped", skipped));
                }
                let what = if parts.is_empty() { "nothing decided".to_string() } else { parts.join(", ") };
                if *left > 0 {
                    format!("Triaged: {}; {} left untouched.", what, left)
                } else {
                    format!("Triaged: {}.", what)
                }
            }
            Message::JiraInboxOpened(key) => format!("Opened {} in browser.", key),
            Message::JiraInboxTaken(key) => format!("Imported {} into tasks.", key),
            Message::ToastActionUnknown(name) => format!("Unknown toast action '{}'; expected take, snooze, dismiss or done.", name),
            Message::ToastActionApplied(what) => format!("{}.", what),
            Message::ToastActionFailed(key, why) => format!("Could not act on {} from the toast: {}", key, why),
            Message::JiraMoved(sentence) => format!("{}.", sentence),
            Message::JiraCommented(key) => format!("Commented on {} in Jira.", key),
            Message::JiraWriteFailed(key, why) => format!("Jira was not updated for {}: {}", key, why),
            Message::JiraResolvedTaskOpen(key, resolution) => format!(
                "{} was resolved in Jira{}; its task is still open - `kasl task find` offers to finish it.",
                key, resolution
            ),
            Message::PromptJiraAfterDone(key) => format!("{} is done here. In Jira", key),
            Message::PromptJiraCloseComment => "Comment to leave on the issue (empty for none)".to_string(),
            Message::PromptJiraComment => "Comment".to_string(),
            Message::PromptMarkResolvedDone => "Resolved in Jira - mark these tasks done (space toggles, enter confirms)".to_string(),
            Message::JiraInboxAlreadyTaken(key, name) => format!("{} is already taken as '{}'.", key, name),
            Message::JiraInboxSummary { total, fresh, taken } => {
                // Only the parts that carry information: "3 in the inbox" says
                // enough when none are new and none are taken.
                let mut parts = Vec::new();
                if *fresh > 0 {
                    parts.push(format!("{} new", fresh));
                }
                if *taken > 0 {
                    parts.push(format!("{} taken", taken));
                }
                let detail = if parts.is_empty() {
                    String::new()
                } else {
                    format!(" ({})", parts.join(", "))
                };
                format!("{} in the inbox{}", total, detail)
            }
            Message::JiraInboxOpenFailed(err) => format!("Failed to open browser: {}", err),
            Message::InboxRulesSkipped(count) => format!("{} inbox rule(s) skipped as unreadable - `kasl inbox rules` says why.", count),
            Message::InboxRuleSkipped(number, why) => format!("Inbox rule {} is skipped: {}.", number, why),
            Message::InboxRuleActed(what) => format!("{}.", what),
            Message::InboxRulesNone => "No inbox rules yet. They go under `jira_inbox.rules` in the config; the Jira inbox guide shows how.".to_string(),
            Message::InboxRulesApplied(0) => "The rules have nothing to change.".to_string(),
            Message::InboxRulesApplied(count) => format!("The rules changed {} issue(s).", count),
            Message::InboxRulesNotApplied(count) => format!(
                "{} issue(s) match a rule that has not acted on them: rules act when an issue arrives or changes. `kasl inbox rules --apply` acts on them now.",
                count
            ),
            Message::PromptJiraInboxEnabled => "Enable Jira inbox polling?".to_string(),
            Message::PromptJiraInboxPollInterval => "Jira inbox poll interval (seconds)".to_string(),
            Message::PromptJiraInboxNotify => "Show toast notifications for new issues?".to_string(),
            Message::PromptJiraInboxSortFieldId => "Sort field id for ranking (e.g. customfield_12345 for Scoring; empty to skip)".to_string(),
            Message::PromptJiraInboxSortFieldLabel => "Label for sort field (default Scoring)".to_string(),
            Message::PromptJiraInboxExtraFieldId => "Additional custom field id to fetch (empty to finish)".to_string(),
            Message::PromptJiraInboxExtraFieldLabel => "Label for this custom field".to_string(),

            // === MIGRATION MESSAGES ===
            Message::MigrationsFound(count) => format!("Found {} pending database migrations", count),
            Message::RunningMigration(version, name) => format!("Running migration v{}: {}", version, name),
            Message::MigrationCompleted(version) => format!("✓ Migration v{} completed", version),
            Message::MigrationFailed(version, error) => format!("✗ Migration v{} failed: {}", version, error),
            Message::AllMigrationsCompleted => "All database migrations completed successfully".to_string(),
            Message::DatabaseVersion(version) => format!("Current database version: {}", version),
            Message::DatabaseUpToDate => "Database schema is up to date".to_string(),
            Message::DatabaseNeedsUpdate => "Database schema needs to be updated".to_string(),
            Message::MigrationHistory => "Migration history:".to_string(),
            Message::NothingToRollback => "Nothing to rollback".to_string(),
            Message::RollingBack(from, to) => format!("Rolling back from v{} to v{}", from, to),
            Message::RollbackCompleted(version) => format!("Rollback to v{} completed", version),
        };

        write!(f, "{}", text)
    }
}