feat(project): include archived in list + add archive/unarchive commands

`/me/projects` is called with `include_archived=true` so client-side
`--status archived`/`all` filtering actually sees archived rows; prior
behavior silently dropped them server-side. Adds `project archive` and
`project unarchive` commands (PUT with `{active}`) and a live round-trip
test covering create → list (active/archived/all) → archive → list →
unarchive → list → delete.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: CorrectRoadH

src/api/client.rs

@@ -37,6 +37,7 @@ use super::models::NetworkProject;
 use super::models::NetworkRenameClient;
 use super::models::NetworkRenameProject;
 use super::models::NetworkRenameTag;
+use super::models::NetworkSetProjectActive;
 use super::models::NetworkTag;
 use super::models::NetworkTask;
 use super::models::NetworkTimeEntry;
@@ -110,6 +111,13 @@ pub trait ApiClient {
         new_name: String,
     ) -> ResultWithDefaultError<Project>;
 
+    async fn set_project_archived(
+        &self,
+        workspace_id: i64,
+        project_id: i64,
+        archived: bool,
+    ) -> ResultWithDefaultError<Project>;
+
     async fn get_tags(&self, workspace_id: i64) -> ResultWithDefaultError<Vec<Tag>>;
 
     async fn create_tag(&self, workspace_id: i64, name: String) -> ResultWithDefaultError<Tag>;
@@ -252,7 +260,10 @@ impl V9ApiClient {
     }
 
     async fn get_projects(&self) -> ResultWithDefaultError<Vec<NetworkProject>> {
-        let url = format!("{}/me/projects", self.base_url);
+        // `include_archived=true` is required for `/me/projects` to return archived
+        // projects; without it the endpoint silently filters them out, so client-side
+        // `--status archived`/`all` filtering would never see them.
+        let url = format!("{}/me/projects?include_archived=true", self.base_url);
         self.get::<Vec<NetworkProject>>(url).await
     }
 
@@ -1026,6 +1037,7 @@ fn cache_ttl_seconds_for_url(url: &str) -> i64 {
 fn is_cacheable_get_url(url: &str) -> bool {
     if url.ends_with("/me")
         || url.ends_with("/me/projects")
+        || url.ends_with("/me/projects?include_archived=true")
         || url.ends_with("/me/tasks")
         || url.ends_with("/me/clients")
         || url.ends_with("/me/workspaces")
@@ -1562,6 +1574,34 @@ impl ApiClient for V9ApiClient {
         })
     }
 
+    async fn set_project_archived(
+        &self,
+        workspace_id: i64,
+        project_id: i64,
+        archived: bool,
+    ) -> ResultWithDefaultError<Project> {
+        let url = format!(
+            "{}/workspaces/{}/projects/{}",
+            self.base_url, workspace_id, project_id
+        );
+        let body = NetworkSetProjectActive { active: !archived };
+        let network_project = self
+            .put::<NetworkProject, NetworkSetProjectActive>(url, &body)
+            .await?;
+        Ok(Project {
+            id: network_project.id,
+            name: network_project.name,
+            workspace_id: network_project.workspace_id,
+            client: None,
+            is_private: network_project.is_private,
+            active: network_project.active,
+            at: network_project.at,
+            created_at: network_project.created_at,
+            color: network_project.color,
+            billable: network_project.billable,
+        })
+    }
+
     async fn get_tags(&self, workspace_id: i64) -> ResultWithDefaultError<Vec<Tag>> {
         let network_tags = self.get_workspace_tags(workspace_id).await?;
         Ok(network_tags

src/api/models.rs

@@ -167,6 +167,11 @@ pub struct NetworkRenameProject {
     pub name: String,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct NetworkSetProjectActive {
+    pub active: bool,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct NetworkCreateClient {
     pub name: String,

src/arguments.rs

@@ -414,6 +414,16 @@ Examples:
         #[arg(help = "Name of the project to delete")]
         name: String,
     },
+    /// Archive a project (sets active=false) without deleting it.
+    Archive {
+        #[arg(help = "Name of the project to archive")]
+        name: String,
+    },
+    /// Unarchive a project (sets active=true).
+    Unarchive {
+        #[arg(help = "Name of the project to unarchive")]
+        name: String,
+    },
 }
 
 #[derive(Subcommand, Debug)]

src/commands/archive_project.rs

@@ -0,0 +1,112 @@
+use crate::api::client::ApiClient;
+use crate::error::ArgumentError;
+use crate::models::ResultWithDefaultError;
+
+pub struct ArchiveProjectCommand;
+
+impl ArchiveProjectCommand {
+    pub async fn execute(
+        api_client: impl ApiClient,
+        name: String,
+        archived: bool,
+    ) -> ResultWithDefaultError<()> {
+        let project = api_client
+            .get_projects_list()
+            .await?
+            .into_iter()
+            .find(|p| p.name == name)
+            .ok_or_else(|| {
+                Box::new(ArgumentError::ResourceNotFound(format!(
+                    "No project found with name '{name}'"
+                ))) as Box<dyn std::error::Error + Send>
+            })?;
+
+        let updated = api_client
+            .set_project_archived(project.workspace_id, project.id, archived)
+            .await?;
+        let verb = if archived { "archived" } else { "unarchived" };
+        println!("Project {verb} successfully\n{updated}");
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::api::client::MockApiClient;
+    use crate::error::ApiError;
+    use crate::models::Project;
+    use chrono::Utc;
+    use tokio_test::{assert_err, assert_ok};
+
+    fn mock_project(active: bool) -> Project {
+        Project {
+            id: 10,
+            name: "Proj".to_string(),
+            workspace_id: 1,
+            client: None,
+            is_private: false,
+            active,
+            at: Utc::now(),
+            created_at: Utc::now(),
+            color: "#06aaf5".to_string(),
+            billable: None,
+        }
+    }
+
+    #[tokio::test]
+    async fn archive_project_sends_active_false() {
+        let mut api_client = MockApiClient::new();
+        api_client
+            .expect_get_projects_list()
+            .returning(|| Ok(vec![mock_project(true)]));
+        api_client
+            .expect_set_project_archived()
+            .withf(|wid, pid, archived| *wid == 1 && *pid == 10 && *archived)
+            .returning(|_, _, _| Ok(mock_project(false)));
+
+        let result = ArchiveProjectCommand::execute(api_client, "Proj".to_string(), true).await;
+        assert_ok!(result);
+    }
+
+    #[tokio::test]
+    async fn unarchive_project_sends_active_true() {
+        let mut api_client = MockApiClient::new();
+        api_client
+            .expect_get_projects_list()
+            .returning(|| Ok(vec![mock_project(false)]));
+        api_client
+            .expect_set_project_archived()
+            .withf(|wid, pid, archived| *wid == 1 && *pid == 10 && !*archived)
+            .returning(|_, _, _| Ok(mock_project(true)));
+
+        let result = ArchiveProjectCommand::execute(api_client, "Proj".to_string(), false).await;
+        assert_ok!(result);
+    }
+
+    #[tokio::test]
+    async fn archive_project_handles_not_found() {
+        let mut api_client = MockApiClient::new();
+        api_client
+            .expect_get_projects_list()
+            .returning(|| Ok(vec![mock_project(true)]));
+
+        let result = ArchiveProjectCommand::execute(api_client, "Missing".to_string(), true).await;
+        assert_err!(result);
+    }
+
+    #[tokio::test]
+    async fn archive_project_handles_api_failure() {
+        let mut api_client = MockApiClient::new();
+        api_client
+            .expect_get_projects_list()
+            .returning(|| Ok(vec![mock_project(true)]));
+        api_client
+            .expect_set_project_archived()
+            .returning(|_, _, _| Err(Box::new(ApiError::Network)));
+
+        let result = ArchiveProjectCommand::execute(api_client, "Proj".to_string(), true).await;
+        assert_err!(result);
+    }
+}

src/commands/mod.rs

@@ -1,3 +1,4 @@
+pub mod archive_project;
 pub mod auth;
 pub mod auth_status;
 pub mod bulk_edit_time_entries;

src/main.rs

@@ -20,6 +20,7 @@ use arguments::{
 };
 use clap::error::ErrorKind;
 use clap::Parser;
+use commands::archive_project::ArchiveProjectCommand;
 use commands::auth::AuthenticationCommand;
 use commands::auth_status::AuthStatusCommand;
 use commands::bulk_edit_time_entries::BulkEditTimeEntriesCommand;
@@ -426,6 +427,12 @@ async fn execute_project_command(
             RenameProjectCommand::execute(api_client, old_name, new_name).await
         }
         ProjectAction::Delete { name } => DeleteProjectCommand::execute(api_client, name).await,
+        ProjectAction::Archive { name } => {
+            ArchiveProjectCommand::execute(api_client, name, true).await
+        }
+        ProjectAction::Unarchive { name } => {
+            ArchiveProjectCommand::execute(api_client, name, false).await
+        }
     }
 }
 

tests/live_cli.rs

@@ -863,6 +863,72 @@ fn live_cli_workspace_resource_crud_succeeds() {
     assert!(find_item_by_name(&projects_after_delete, &renamed_project_name).is_none());
 }
 
+/// Covers the archive/unarchive project commands and verifies that
+/// `project list --status archived` / `--status all` actually surface archived
+/// projects. Regression guard for the bug where `/me/projects` was called
+/// without `include_archived=true`, so client-side status filtering never saw
+/// archived rows.
+#[test]
+fn live_cli_project_archive_round_trip_succeeds() {
+    let _guard = acquire_live_test_guard();
+    require_live_test_env();
+
+    let mut cleanup = CleanupState::default();
+    ensure_test_workspace_scope();
+    let project_name = unique_description("archive-proj");
+
+    run_checked(&["project", "create", &project_name]);
+    cleanup.project_name = Some(project_name.clone());
+    wait_for_named_resource(
+        "created project missing from project list",
+        &["project", "list", "--json"],
+        &project_name,
+    );
+
+    // Default list (active) must include it; archived list must not.
+    let active_before = run_json_array_command(&["project", "list", "--json"]);
+    assert!(find_item_by_name(&active_before, &project_name).is_some());
+    let archived_before =
+        run_json_array_command(&["project", "list", "--json", "--status", "archived"]);
+    assert!(find_item_by_name(&archived_before, &project_name).is_none());
+
+    // Archive it.
+    run_checked(&["project", "archive", &project_name]);
+
+    // After archiving: must disappear from active, appear under archived + all.
+    // Poll archived because mutations propagate asynchronously in OpenToggl.
+    wait_for_named_resource(
+        "archived project missing from --status archived list",
+        &["project", "list", "--json", "--status", "archived"],
+        &project_name,
+    );
+    let active_after_archive = run_json_array_command(&["project", "list", "--json"]);
+    assert!(
+        find_item_by_name(&active_after_archive, &project_name).is_none(),
+        "archived project should not appear in default (active) list"
+    );
+    let all_after_archive =
+        run_json_array_command(&["project", "list", "--json", "--status", "all"]);
+    assert!(find_item_by_name(&all_after_archive, &project_name).is_some());
+
+    // Unarchive it.
+    run_checked(&["project", "unarchive", &project_name]);
+    wait_for_named_resource(
+        "unarchived project missing from active list",
+        &["project", "list", "--json"],
+        &project_name,
+    );
+    let archived_after_unarchive =
+        run_json_array_command(&["project", "list", "--json", "--status", "archived"]);
+    assert!(
+        find_item_by_name(&archived_after_unarchive, &project_name).is_none(),
+        "unarchived project should not appear in archived list"
+    );
+
+    run_checked(&["project", "delete", &project_name]);
+    cleanup.project_name = None;
+}
+
 #[test]
 fn live_cli_preferences_round_trip_succeeds() {
     let _guard = acquire_live_test_guard();