Board cards can be archived, by hand or by age (refs #293) 439ecd8708a1

-- Archived board cards (oxygenhub#293): off the board, kept, found with

-- the board's archive view and restorable. NULL while on the board.

ALTER TABLE project_cards ADD COLUMN archived_ms BIGINT;

-- When a card joined its column, so a column's cards can be archived some

-- days after they reached it (Done after 14 days).

ALTER TABLE project_cards ADD COLUMN moved_ms BIGINT NOT NULL DEFAULT 0;

UPDATE project_cards SET moved_ms = created_ms;

-- A column whose cards are archived this many days after they joined it;

-- NULL never.

ALTER TABLE project_columns ADD COLUMN archive_after_days BIGINT;

-- Archived board cards (oxygenhub#293): off the board, kept, found with

-- the board's archive view and restorable. NULL while on the board.

ALTER TABLE project_cards ADD COLUMN archived_ms INTEGER;

-- When a card joined its column, so a column's cards can be archived some

-- days after they reached it (Done after 14 days).

ALTER TABLE project_cards ADD COLUMN moved_ms INTEGER NOT NULL DEFAULT 0;

UPDATE project_cards SET moved_ms = created_ms;

-- A column whose cards are archived this many days after they joined it;

-- NULL never.

ALTER TABLE project_columns ADD COLUMN archive_after_days INTEGER;

- **Board cards can be archived (#293, archive):** off the board but kept, on the board's archive view (`?archived=1`, with the same filter) and restored to the end of their column. A column archives its cards that reached it more than N days ago at once ("Archive cards here more than 14 days"), or on its own once set to (checked hourly, `projects.archiver`), so a Done column stops growing. An issue's or proposal's page says its card is archived. The API has `POST …/cards/archive` (#289's selection plus `older_days`, with `dry_run`), `GET …/cards?archived=true` and `POST …/cards/{id}/restore`; `oh project card archive N --from Done --older 14d`, `oh project card restore N CARD` and `oh project view N --archived`. Migration 0093 adds `project_cards.archived_ms` and `moved_ms` (when a card joined its column) and `project_columns.archive_after_days`.

    /// When it was archived (ms), for an archived card (oxygenhub#293).

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub archived_ms: Option<i64>,

    pub kept: Vec<ProjectCard>,

    pub dry_run: bool,

}

/// `POST /projects/{owner}/{n}/cards/archive` (oxygenhub#293): take the

/// cards of column `from` off the board, kept and restorable, but those

/// `except` names and, given `state`, only cards whose issue or proposal is

/// in one of them; given `older_days`, only cards that joined the column

/// more than that many days ago. With `dry_run`, nothing is archived.

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]

pub struct CardsArchive {

    pub from: String,

    #[serde(default)]

    pub older_days: Option<i64>,

    #[serde(default)]

    pub except: Vec<String>,

    #[serde(default)]

    pub state: Vec<String>,

    #[serde(default)]

    pub dry_run: bool,

}

/// What an archive took off the board, and what it left in the column.

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]

pub struct CardsArchived {

    pub archived: Vec<ProjectCard>,

        .route("/projects/{owner}/{number}/cards/archive", post(projects::archive_cards))

        .route("/projects/{owner}/{number}/cards/{id}/restore", post(projects::restore_card))

use axum::extract::{Path, Query, State};

use hub_api::{

    Board, CardMove, CardsArchive, CardsArchived, CardsMove, CardsMoved, NewCard, NewProject, Project, ProjectCard, ProjectColumn,

    ProjectEdit,

};

        archived_ms: v.card.archived_ms,

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

#[derive(serde::Deserialize, Default)]

pub struct CardsQuery {

    /// The archived cards instead (#293).

    #[serde(default)]

    archived: bool,

}

/// `GET /projects/{owner}/{n}/cards`, `?archived=true` for the archived ones.

    Query(q): Query<CardsQuery>,

    if !q.archived {

        return Ok(Json(board(State(app), headers, Path((owner, number))).await?.0.columns));

    }

    let c = caller(&app, &headers).await?;

    let (_, p) = visible(&app, &c, &owner, number).await?;

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, true).await?;

    Ok(Json(

        columns

            .iter()

            .map(|col| ProjectColumn { id: col.column.id, name: col.column.name.clone(), cards: col.cards.iter().map(card_of).collect() })

            .collect(),

    ))

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

}

/// `POST /projects/{owner}/{n}/cards/archive` (#293): a column's cards off

/// the board at once, kept, with #289's exceptions and state filter and an

/// age; one audit entry.

pub async fn archive_cards(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number)): Path<(String, i64)>,

    Json(body): Json<CardsArchive>,

) -> Result<Json<CardsArchived>, ApiError> {

    let (c, p) = changeable(&app, &headers, &owner, number, false).await?;

    let from = column(&app, p.id, Some(&body.from)).await?;

    if body.older_days.is_some_and(|d| !(0..=3650).contains(&d)) {

        return Err(ApiError(StatusCode::BAD_REQUEST, "older_days is 0 to 3650".into()));

    }

    let (columns, _) = wp::board_columns(&app, c.account.as_ref(), &owner, &p, false).await?;

    let now = crate::db::now_ms();

    let states: Vec<String> = body.state.iter().map(|s| s.trim().to_ascii_lowercase()).filter(|s| !s.is_empty()).collect();

    let (archived, kept): (Vec<&wp::CardView>, Vec<&wp::CardView>) =

        columns.iter().filter(|col| col.column.id == from.id).flat_map(|col| col.cards.iter()).partition(|v| {

            let card = card_of(v);

            !body.except.iter().any(|e| names_card(e, &card))

                && (states.is_empty() || states.iter().any(|s| card.state.eq_ignore_ascii_case(s)))

                && body.older_days.is_none_or(|d| pdb::older_than(&v.card, d, now))

        });

    if !body.dry_run && !archived.is_empty() {

        let ids: Vec<i64> = archived.iter().map(|v| v.card.id).collect();

        pdb::archive_cards(&app.db, p.id, &ids).await?;

        let detail = format!("{} card(s) of {}", ids.len(), from.name);

        crate::db::accounts::audit(&app.db, c.account.as_ref(), "project.cards_archived", &format!("{owner}/{number}"), &detail).await.ok();

    }

    let stamp = |v: &wp::CardView| ProjectCard { archived_ms: (!body.dry_run).then_some(now), ..card_of(v) };

    Ok(Json(CardsArchived {

        archived: archived.into_iter().map(stamp).collect(),

        kept: kept.into_iter().map(card_of).collect(),

        dry_run: body.dry_run,

    }))

}

/// `POST /projects/{owner}/{n}/cards/{id}/restore` (#293): an archived

/// card back on the board, at the end of its column.

pub async fn restore_card(

    State(app): State<Shared>,

    headers: HeaderMap,

    Path((owner, number, id)): Path<(String, i64, i64)>,

) -> Result<StatusCode, ApiError> {

    let (_, p) = changeable(&app, &headers, &owner, number, false).await?;

    if !pdb::cards(&app.db, p.id).await?.iter().any(|c| c.id == id && c.archived_ms.is_some()) {

        return Err(not_found("no such archived card"));

    }

    pdb::restore_card(&app.db, p.id, id).await?;

    Ok(StatusCode::NO_CONTENT)

    /// Its cards are archived this many days after they joined it (#293).

    pub archive_after_days: Option<i64>,

    /// Off the board since then (#293): kept, and restorable.

    pub archived_ms: Option<i64>,

    /// When it joined its column.

    pub moved_ms: i64,

/// A day, for the archive's ages.

const DAY_MS: i64 = 86_400_000;

        "INSERT INTO project_cards (project_id, column_id, position, kind, repo_id, number, note, added_by, created_ms, moved_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $9) ON CONFLICT DO NOTHING",

    sqlx::query("UPDATE project_cards SET moved_ms = CASE WHEN column_id = $1 THEN moved_ms ELSE $3 END, column_id = $1, position = $2 WHERE id = $4 AND project_id = $5")

        .bind(now_ms())

    let now = now_ms();

        sqlx::query("UPDATE project_cards SET column_id = $1, position = $2, moved_ms = $3 WHERE id = $4 AND project_id = $5")

            .bind(now)

    sqlx::query("UPDATE projects SET updated_ms = $1 WHERE id = $2").bind(now).bind(project_id).execute(&mut *tx).await?;

}

/// Take `card_ids` off the board, kept (#293); how many were on it.

pub async fn archive_cards(pool: &Pool, project_id: i64, card_ids: &[i64]) -> sqlx::Result<u64> {

    let mut tx = pool.begin().await?;

    let now = now_ms();

    let mut n = 0;

    for id in card_ids {

        n += sqlx::query("UPDATE project_cards SET archived_ms = $1 WHERE id = $2 AND project_id = $3 AND archived_ms IS NULL")

            .bind(now)

            .bind(id)

            .bind(project_id)

            .execute(&mut *tx)

            .await?

            .rows_affected();

    }

    sqlx::query("UPDATE projects SET updated_ms = $1 WHERE id = $2").bind(now).bind(project_id).execute(&mut *tx).await?;

    tx.commit().await?;

    Ok(n)

}

/// Put an archived card back on the board, at the end of its column, as

/// if it had just joined it (so its column does not archive it again at

/// once); `false` when it was not archived.

pub async fn restore_card(pool: &Pool, project_id: i64, card_id: i64) -> sqlx::Result<bool> {

    let mut tx = pool.begin().await?;

    let pos: i64 = sqlx::query_scalar(

        "SELECT COALESCE(MAX(position), -1) + 1 FROM project_cards WHERE column_id = (SELECT column_id FROM project_cards WHERE id = $1)",

    )

    .bind(card_id)

    .fetch_one(&mut *tx)

    .await?;

    let now = now_ms();

    let r = sqlx::query(

        "UPDATE project_cards SET archived_ms = NULL, moved_ms = $1, position = $2 WHERE id = $3 AND project_id = $4 AND archived_ms IS NOT NULL",

    )

    .bind(now)

    .bind(pos)

    .bind(card_id)

    .bind(project_id)

    .execute(&mut *tx)

    .await?;

    sqlx::query("UPDATE projects SET updated_ms = $1 WHERE id = $2").bind(now).bind(project_id).execute(&mut *tx).await?;

    tx.commit().await?;

    Ok(r.rows_affected() == 1)

}

/// Whether `card` joined its column more than `days` ago, at `now`.

pub fn older_than(card: &Card, days: i64, now: i64) -> bool {

    card.moved_ms < now - days * DAY_MS

}

/// Archive a column's cards this many days after they join it, or never.

pub async fn set_archive_after(pool: &Pool, project_id: i64, column_id: i64, days: Option<i64>) -> sqlx::Result<()> {

    sqlx::query("UPDATE project_columns SET archive_after_days = $1 WHERE id = $2 AND project_id = $3")

        .bind(days)

        .bind(column_id)

        .bind(project_id)

        .execute(pool)

        .await?;

    touch(pool, project_id).await

}

/// Archive, on every board, the cards of columns that archive after some

/// days which joined them longer ago than that (#293); how many.

pub async fn archive_due(pool: &Pool, now: i64) -> sqlx::Result<u64> {

    let r = sqlx::query(

        "UPDATE project_cards SET archived_ms = $1 WHERE archived_ms IS NULL AND EXISTS \

         (SELECT 1 FROM project_columns c WHERE c.id = project_cards.column_id AND c.archive_after_days IS NOT NULL \

          AND project_cards.moved_ms < $1 - c.archive_after_days * $2)",

    )

    .bind(now)

    .bind(DAY_MS)

    .execute(pool)

    .await?;

    Ok(r.rows_affected())

    let rows: Vec<(i64, String, Option<i64>)> = sqlx::query_as(

        "SELECT c.project_id, col.name, c.archived_ms FROM project_cards c JOIN project_columns col ON col.id = c.column_id WHERE c.repo_id = $1 AND c.number = $2 AND c.kind <> 'note'",

    for (pid, col, archived) in rows {

        let col = if archived.is_some() { format!("{col}, archived") } else { col };

    leader::run(app, "projects.archiver", maintenance::archiver);

/// Each hour, archive the cards of columns that archive after some days

/// once they have been there longer (#293).

pub async fn archiver(app: Shared) {

    loop {

        match crate::db::projects::archive_due(&app.db, crate::db::now_ms()).await {

            Ok(n) if n > 0 => tracing::info!("projects: archived {n} card(s) their columns keep no longer"),

            Ok(_) => {}

            Err(e) => tracing::warn!("projects: archiving failed: {e}"),

        }

        tokio::time::sleep(std::time::Duration::from_secs(3600)).await;

    }

}

    /// Its archived cards (#293), shown on the archive view.

    pub archived: usize,

    /// The archived cards instead (`?archived=1`).

    #[serde(default)]

    archived: Option<String>,

    }

    fn archived(&self) -> bool {

        self.archived.as_deref().is_some_and(|a| !a.is_empty() && a != "0")

        } else if col.cards.len() > COLUMN_SHOWN && view.all != Some(col.column.id) && !view.archived() {

    /// The archive view: archived cards, each restorable (#293).

    archived: bool,

    /// Archived cards on the whole board.

    archived_total: usize,

    let archived = view.archived();

    let (mut columns, repos) = board_columns(app, viewer.account(), owner, &project, archived).await.map_err(e)?;

    let archived_total = columns.iter().map(|c| c.archived).sum();

    Ok(Page(BoardPage {

        shell,

        project,

        columns,

        repos,

        can_edit,

        can_manage: r.edit,

        notice,

        error,

        transfer_to,

        q,

        state,

        filtered,

        archived,

        archived_total,

    }))

/// repositories it can read (for adding cards). `archived`: the archived

/// cards instead of those on the board (#293); each column counts its

/// archived cards either way.

    archived: bool,

    let all = pdb::cards(&app.db, project.id).await?;

    let archived_in = |column: i64| all.iter().filter(|c| c.column_id == column && c.archived_ms.is_some()).count();

    let cards: Vec<&pdb::Card> = all.iter().filter(|c| c.archived_ms.is_some() == archived).collect();

        for card in cards.iter().copied().filter(|c| c.column_id == column.id) {

        let archived = archived_in(column.id);

        columns.push(ColumnView { column, cards: views, hidden: 0, total, archived });

    /// Days, for archiving a column's older cards (#293); empty is never.

    #[serde(default)]

    days: String,

            }

        }

        "archive" => {

            if let Some(card) = f.card {

                pdb::archive_cards(&app.db, project.id, &[card]).await.map_err(e)?;

            }

        }

        "restore" => {

            if let Some(card) = f.card {

                pdb::restore_card(&app.db, project.id, card).await.map_err(e)?;

            }

            return Ok(Redirect::to(&format!("/projects/{owner}/{number}?archived=1")).into_response());

        }

        "archive_older" | "archive_after" => {

            let Some(col) = f.column else { return Err(Error::bad(shell, "no column")) };

            let days = match f.days.trim() {

                "" if f.action == "archive_after" => None,

                d => match d.parse::<i64>() {

                    Ok(n) if (0..=3650).contains(&n) => Some(n),

                    _ => {

                        error = Some("Give a number of days, 0 to 3650.".into());

                        None

                    }

                },

            };

            let name = columns.iter().find(|c| c.id == col).map(|c| c.name.clone()).unwrap_or_default();

            if error.is_none() && f.action == "archive_after" {

                pdb::set_archive_after(&app.db, project.id, col, days).await.map_err(e)?;

                notice = Some(match days {

                    Some(n) => format!("{name} archives its cards {n} day{} after they reach it.", if n == 1 { "" } else { "s" }),

                    None => format!("{name} keeps its cards until you archive them."),

                });

            } else if let (None, Some(days)) = (&error, days) {

                let now = db::now_ms();

                let ids: Vec<i64> = pdb::cards(&app.db, project.id)

                    .await

                    .map_err(e)?

                    .into_iter()

                    .filter(|c| c.column_id == col && c.archived_ms.is_none() && pdb::older_than(c, days, now))

                    .map(|c| c.id)

                    .collect();

                let n = pdb::archive_cards(&app.db, project.id, &ids).await.map_err(e)?;

                let detail = format!("{n} card(s) of {name} older than {days} days");

                db::accounts::audit(&app.db, viewer.account(), "project.cards_archived", &format!("{owner}/{number}"), &detail).await.ok();

                notice = Some(format!("Archived {n} card{} from {name}.", if n == 1 { "" } else { "s" }));

    // Archive (#293): Done's cards there more than a week (#3, made old),

    // listed with ?archived=true, restored once.

    sqlx::query("UPDATE project_cards SET moved_ms = 0 WHERE number = 3").execute(&app.db).await.unwrap();

    let archive = |body: &'static str| api(app, "POST", "/api/v1/projects/andy/1/cards/archive", Some(&a), Some(body));

    let (st, v) = archive(r#"{"from":"Done","older_days":7,"dry_run":true}"#).await;

    assert_eq!((st, refs(&v, "archived")), (StatusCode::OK, vec!["andy/demo#3".to_string()]), "{v}");

    assert!(v["archived"][0].get("archived_ms").is_none(), "a dry run archives nothing: {v}");

    let (_, v) = archive(r#"{"from":"Done","older_days":7}"#).await;

    assert_eq!((refs(&v, "archived"), refs(&v, "kept").len()), (vec!["andy/demo#3".to_string()], 1), "{v}");

    assert!(v["archived"][0]["archived_ms"].as_i64().is_some());

    let (_, board) = api(app, "GET", "/api/v1/projects/andy/1", None, None).await;

    assert_eq!(board["columns"][2]["cards"].as_array().unwrap().len(), 1, "off the board: {board}");

    let (st, archived) = api(app, "GET", "/api/v1/projects/andy/1/cards?archived=true", None, None).await;

    assert_eq!((st, archived[2]["cards"][0]["reference"].as_str()), (StatusCode::OK, Some("andy/demo#3")), "{archived}");

    let card = archived[2]["cards"][0]["id"].as_i64().unwrap();

    let restore = format!("/api/v1/projects/andy/1/cards/{card}/restore");

    assert_eq!(api(app, "POST", &restore, Some(&b), None).await.0, StatusCode::FORBIDDEN);

    assert_eq!(api(app, "POST", &restore, Some(&a), None).await.0, StatusCode::NO_CONTENT);

    assert_eq!(api(app, "POST", &restore, Some(&a), None).await.0, StatusCode::NOT_FOUND, "not archived now");

    let (_, board) = api(app, "GET", "/api/v1/projects/andy/1", None, None).await;

    assert_eq!(board["columns"][2]["cards"].as_array().unwrap().len(), 2);

    assert_eq!(archive(r#"{"from":"Done","older_days":-1}"#).await.0, StatusCode::BAD_REQUEST);

    let audited: i64 =

        sqlx::query_scalar("SELECT COUNT(*) FROM audit WHERE action = 'project.cards_archived'").fetch_one(&app.db).await.unwrap();

    assert_eq!(audited, 1);

/// #293: a card is archived off the board, kept and found on the archive

/// view, and restored; a column archives its cards older than some days

/// at once, or on its own once set to; an issue's page says its card is

/// archived.

async fn board_cards_are_archived_and_restored() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let csrf = csrf_of(&get(app, "/projects/andy", Some(&andy)).await.body);

    post(app, "/projects/andy", Some(&andy), &format!("_csrf={csrf}&title=Roadmap")).await;

    let (project, done): (i64, i64) =

        sqlx::query_as("SELECT p.id, c.id FROM projects p JOIN project_columns c ON c.project_id = p.id WHERE c.name = 'Done'")

            .fetch_one(&app.db)

            .await

            .unwrap();

    let day = 86_400_000i64;

    let now = db::now_ms();

    for (i, age) in [40, 20, 10, 1].iter().enumerate() {

        sqlx::query(

            "INSERT INTO project_cards (project_id, column_id, position, kind, note, created_ms, moved_ms) VALUES ($1, $2, $3, 'note', $4, 0, $5)",

        )

        .bind(project)

        .bind(done)

        .bind(i as i64)

        .bind(format!("aged-{age}"))

        .bind(now - age * day)

        .execute(&app.db)

        .await

        .unwrap();

    }

    let id_of = |note: &'static str| async move {

        sqlx::query_scalar::<_, i64>("SELECT id FROM project_cards WHERE note = $1").bind(note).fetch_one(&app.db).await.unwrap()

    };

    let board = "/projects/andy/1";

    let (who, token) = (&andy, &csrf);

    let act = |body: String| async move { post(app, board, Some(who), &format!("_csrf={token}&{body}")).await };

    // One card by hand: off the board, on the archive view, restorable.

    let forty = id_of("aged-40").await;

    act(format!("action=archive&card={forty}")).await;

    let page = get(app, board, Some(&andy)).await.body;

    assert!(!page.contains("aged-40") && page.contains("aged-20"), "{page}");

    assert!(page.contains("?archived=1\">1 archived card</a>"), "{page}");

    let archived = get(app, &format!("{board}?archived=1"), Some(&andy)).await.body;

    assert!(archived.contains("aged-40") && !archived.contains("aged-20"), "{archived}");

    assert!(archived.contains("value=\"restore\"") && archived.contains("Back to the board"));

    assert!(!archived.contains("add a card"), "the archive view adds nothing");

    let found = get(app, &format!("{board}?archived=1&q=aged-40"), Some(&andy)).await.body;

    assert!(found.contains("1 of 1") && found.contains("name=\"archived\" value=\"1\""), "{found}");

    act(format!("action=restore&card={forty}")).await;

    assert!(get(app, board, Some(&andy)).await.body.contains("aged-40"));

    // The column's cards there more than 15 days, at once: 40 (just

    // restored, so it joined again now) stays, 20 goes.

    let r = act(format!("action=archive_older&column={done}&days=15")).await;

    assert!(r.body.contains("Archived 1 card from Done."), "{}", r.body);

    let page = get(app, board, Some(&andy)).await.body;

    assert!(page.contains("aged-40") && !page.contains("aged-20") && page.contains("aged-10"));

    let r = act(format!("action=archive_older&column={done}&days=soon")).await;

    assert!(r.body.contains("Give a number of days"), "{}", r.body);

    // On its own: Done after 5 days; the hourly pass takes aged-10 only.

    let r = act(format!("action=archive_after&column={done}&days=5")).await;

    assert!(r.body.contains("Done archives its cards 5 days after they reach it."), "{}", r.body);

    assert!(get(app, board, Some(&andy)).await.body.contains("archives cards 5 days after they reach it"));

    assert_eq!(db::projects::archive_due(&app.db, db::now_ms()).await.unwrap(), 1);

    let page = get(app, board, Some(&andy)).await.body;

    assert!(page.contains("aged-40") && !page.contains("aged-10") && page.contains("aged-1<"), "{page}");

    assert!(page.contains("2 archived cards"));

    let r = act(format!("action=archive_after&column={done}&days=")).await;

    assert!(r.body.contains("Done keeps its cards until you archive them."));

    assert_eq!(db::projects::archive_due(&app.db, db::now_ms() + 100 * day).await.unwrap(), 0, "never, now");

}

#[tokio::test(flavor = "multi_thread")]

const WORKER_SINGLETONS: [&str; 9] = [

    "projects.archiver",

    assert_eq!(app.leader.tasks().len(), 13, "{:?}", app.leader.tasks());

    View {

        number: i64,

        /// Its archived cards instead (#293)

        #[arg(long)]

        archived: bool,

    },

    /// Cards on a board: add, move, archive, restore, remove

        dry_run: bool,

    },

    /// Archive a column's cards: off the board, kept and restorable (#293)

    Archive {

        number: i64,

        /// The column, by name or id

        #[arg(long)]

        from: String,

        /// Only cards that joined the column more than this long ago (14d, or 14)

        #[arg(long)]

        older: Option<String>,

        /// Leave these on the board (card ids, or 12, #12, name#12, owner/name#12), comma-separated

        #[arg(long, value_delimiter = ',')]

        except: Vec<String>,

        /// Only cards whose issue or proposal is in one of these states (closed, landed…), comma-separated

        #[arg(long, value_delimiter = ',')]

        state: Vec<String>,

        /// Say what would be archived, and archive nothing

        #[arg(long)]

    /// Put an archived card back at the end of its column

    Restore { number: i64, card: i64 },

        ProjectCmd::View { number, archived } => {

            let cards = format!("{path}/cards?archived=true");

                println!("{}", c.get_text(if archived { &cards } else { &path })?);

            let mut b: hub_api::Board = c.get(&path)?;

            if archived {

                b.columns = c.get(&cards)?;

            }

        ProjectCmd::Card { cmd: CardCmd::Archive { number, from, older, except, state, dry_run } } => {

            let older_days = match older.as_deref().map(|o| o.trim().trim_end_matches('d')) {

                None => None,

                Some(d) => Some(d.parse::<i64>().map_err(|_| anyhow::anyhow!("--older takes days: 14d, or 14"))?),

            };

            let r: hub_api::CardsArchived = c.send(

                "POST",

                &format!("{base}/{number}/cards/archive"),

                &hub_api::CardsArchive { from: from.clone(), older_days, except, state, dry_run },

            )?;

            if json {

                println!("{}", serde_json::to_string(&r)?);

                return Ok(0);

            }

            let verb = if dry_run { "would archive" } else { "archived" };

            for a in &r.archived {

                let name = if a.reference.is_empty() { a.title.clone() } else { a.reference.clone() };

                println!("  {verb} {name}  {}", ui::dim(&a.title));

            }

            println!("{} {verb} {} card(s) from {from}; {} left on the board", ui::ok("✔"), r.archived.len(), r.kept.len());

        }

        ProjectCmd::Card { cmd: CardCmd::Restore { number, card } } => {

            c.send_text("POST", &format!("{base}/{number}/cards/{card}/restore"), &serde_json::json!({}))?;

            println!("{} card {card} restored", ui::ok("✔"));

        }

`diffusion.backfill`, `diffusion.reconciler`, `secrets.history_scan`,

`projects.archiver` (worker role) and `tlog.checkpointer` (web role, below).

- Long boards (oxygenhub#293): a column of more than 30 cards shows its newest 30, with "show all". A card shows its issue's or proposal's labels and an issue's assignees, and the filter above the board takes words (title or reference) with `label:NAME`, `assignee:NAME` and `state:STATE`, every term holding, as the issue list does.

- Archive (oxygenhub#293): a card can be archived, off the board but kept, found on the board's archive view (`?archived=1`, filtered the same way) and restored to the end of its column. A column archives its cards that joined it more than N days ago at once, or does so on its own once set to (Done after 14 days, say; checked hourly). An issue's or proposal's page says when its card is archived.

JSON under `/api/v1`, bearer tokens, `application/json`, RFC 7807 problem responses (an unknown route, or a known one with the wrong method, too), cursor pagination (`?after=`), ETags on cacheable resources, and rate limits per token. Resources mirror the pages: `/repos/{owner}/{name}`, `/bookmarks`, `/changes/{hash}`, `/tree/{ref}/{path}`, `/file/{ref}/{path}`, `/blame`, `/history/{ref}` (`?path=`, `?offset=&limit=`, or `?r=REVSET` for the changes a revset selects, evaluated under a two-second budget and answering 400 when it does not parse or goes past it; Oxygen's docs/revset_query_language.md), `/compare`, `/conflicts`, `/proposals` (`?state=open|draft|landed|closed|all`, open ones and drafts by default; a source bookmark may hold `/`, and `owner/name:bookmark` naming the repository itself is its own bookmark), `/proposals/{n}/comments|reviews|checks|files`, `PATCH /proposals/{n}` (the title and description, for its author or a maintainer, and `labels`, the whole set by name, for triage; what is not given stays), `POST /proposals/{n}/land` (repo:write: what the Land button does, `409` with the blockers when it cannot; a landed proposal keeps the changes it landed and reports `landed` with who, how (`web`, or `api (token NAME)`) and when, which its event, the audit log and the push record also say, adding when nobody approved), `/proposals/{n}/content/{base|head}/{path}` (a changed file's bytes in the target's state or the projected state, for editor diff views), `/issues` (creating an issue can set its labels, assignees and milestone; `PATCH /issues/{n}` edits the title and body for the author or triage, and replaces labels, assignees or the milestone for triage, recording each on the timeline; unknown names are refused before anything changes), `/labels` (`POST` creates or changes one, `DELETE /labels/{name}` removes it; triage), `/milestones` (`POST` creates one or changes the description and due date of the one with that title, `PATCH /milestones/{title}` changes title, description, due date or state; triage), `/releases` (`PATCH /releases/{tag}` changes the title, notes or prerelease flag, repo:write), `/tags` (`POST` creates one, repo:write; `DELETE /tags/{tag}` withdraws one, a maintainer, `409` while a release uses it; §9), `/trust`, `/pushes`, `/hooks`, `/checks`, `/user`, `/user/repos` (the caller's own, organisations' and collaborations, `?affiliation=&after=&limit=`, #302), `/user/orgs`, `/notifications` (the caller's inbox and unread count, each with its repository, reason, thread and label, #305; `/notifications/{id}/read` and `/notifications/read` mark read; scope `user:read`), `/users/{name}`, `/users/{name}/drops` and `/drops` (§4.5), `/orgs/{name}`, `/checks/{state}` (the checks on a state, named by its hash, by its heads joined with `+`, by the one head of a single-head state, or by a bookmark), `/checks/required` (`GET`, and `PUT` of the whole list by a repository admin: the checks a proposal needs, passed, to land), `/projects/{owner}` (list, create) and `/projects/{owner}/{n}` (the board as the caller may see it, `PATCH` for title, description, privacy and closing, and `owner` to transfer it to an owner the caller may make boards under (#125: it takes the next number there, and its old address redirects), `/cards` to list them by column or add a reference or note to a column named by id or name, `/cards/{id}` to move or remove one, `POST /cards/move` (#289: `{"from", "column", "except", "state", "dry_run"}`) to move a column's cards at once, but those `except` names (card ids or issue and proposal references) and, given `state`, only those whose issue or proposal is in one, all or none and audited once, answering what moved and what was kept; `POST /cards/archive` (#293: `{"from", "older_days", "except", "state", "dry_run"}`, the same selection and an age) to archive them, `GET /cards?archived=true` to list the archived ones (each with `archived_ms`) and `POST /cards/{id}/restore` to put one back; cards carry their `labels` and `assignees`; `repo:write` and the page's rights to change), `/coverage` and `/tests` (a bookmark's coverage and JUnit test reports from Flow jobs, newest first, `?bookmark=&limit=`), `POST /coverage` (repo:write, #136: `{"bookmark"}` or `{"change"}` and `content`, an LCOV or Cobertura report measured off the hub, kept for that state as uploaded by the caller, shown "uploaded by NAME" wherever a run number would be, and setting no check; `oh coverage upload FILE`), `/coverage/{id}` (a report with its files) and `/tests/{id}` (a report with its cases, `?status=failed` for the failed and errored ones), `/flow/runs` (`GET`: runs newest first, `?before=N&limit=`; `POST {"bookmark"}` or `{"change"}`, repo:write: run a bookmark's current state, the default bookmark when none is named, or one change's state; with `"jobs": [NAME..]` only those jobs and what they depend on, each one a manual run starts, else `409` naming the ones it does (#130); `oh run start --job NAME`), `/flow/runs/{n}` (a run with its jobs), `/flow/runs/{n}/jobs/{job}/log` (`?after=seq&limit=`) and `/flow/runs/{n}/rerun` (repo:write: a finished run again), both answering `201 {"number", "url"}` or `409` with why nothing started, `/flow/runs/{n}/jobs/{job}/rerun` (repo:write, oxygenflow#31: that job of a finished run again, in the same run, with the jobs that depend on it; what it depends on keeps its result, so a flaky test reruns without its build; their logs, artifacts and reports go, their checks return to queued and the run is running again; `{"queued": N}`, or `409` while the run is live or for a job it lacks; RE-RUN THIS JOB on the run page, `oh run rerun N --job NAME`), `/flow/runs/{n}/cancel` (repo:write: a run still going ends as `cancelled`, its running jobs stopped when their runner next reports; `409` when it had already ended; a push to a bookmark cancels the push runs of it still going), `/search`. A change's author carries the account its key is linked to, or `null` and a `note` saying the key is not linked and where its owner links it; `via` names the delegate (an agent) that signed for the author when one did, with the delegation's scope and expiry and whether it has since been revoked, and the pages show the same as an `agent` badge, a `via` row under the author on the change page, and a count under the author in Contributors (the change page shows a "key not linked" tag, with a link to Settings → Keys for signed-in viewers). Shapes reuse `oxy --json` shapes wherever one exists (change, status, blame, diff) so tools written against the CLI work against the hub. `crates/hub-api` holds the types with `serde` derives and is what the runner and the VS Code extension will link.

{% if archived %}<p class="note board-archive-note">Archived cards: off the board, kept and searchable{% if can_edit %}; restore one to put it back at the end of its column{% endif %}. <a href="/projects/{{ project.owner }}/{{ project.number }}">Back to the board</a></p>{% endif %}

<form class="board-filter" method="get" action="/projects/{{ project.owner }}/{{ project.number }}" role="search">{% if archived %}<input type="hidden" name="archived" value="1">{% endif %}

  <button type="submit" class="small">FILTER</button>{% if filtered %} <a class="small" href="/projects/{{ project.owner }}/{{ project.number }}{% if archived %}?archived=1{% endif %}">clear</a>{% endif %}

  {% if !archived && archived_total > 0 %}<a class="small board-archived-link" href="/projects/{{ project.owner }}/{{ project.number }}?archived=1">{{ archived_total }} archived card{% if archived_total != 1 %}s{% endif %}</a>{% endif %}

  {% if can_edit && !archived %}<form class="tiny" method="post" action="/projects/{{ project.owner }}/{{ project.number }}"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="column" value="{{ col.column.id }}"><button name="action" value="left" title="Move the column left" aria-label="Move {{ col.column.name }} left">←</button><button name="action" value="right" title="Move the column right" aria-label="Move {{ col.column.name }} right">→</button></form>{% endif %}</header>

  {% if let Some(d) = col.column.archive_after_days %}{% if !archived %}<p class="small mute col-archives">archives cards {{ d }} day{% if *d != 1 %}s{% endif %} after they reach it</p>{% endif %}{% endif %}

  {% if col.hidden > 0 && !filtered && !archived %}<p class="small mute col-hidden">{{ col.hidden }} older card{% if col.hidden != 1 %}s{% endif %} not shown · <a href="/projects/{{ project.owner }}/{{ project.number }}?all={{ col.column.id }}#col-{{ col.column.id }}">show all {{ col.total }}</a></p>{% endif %}

      {% if let Some(t) = c.card.archived_ms %}<p class="small mute">archived <time title="{{ t|when_i }}">{{ t|ago_i }}</time></p>{% endif %}

      {% if can_edit && archived %}

      <form class="tiny card-actions" method="post" action="/projects/{{ project.owner }}/{{ project.number }}"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="card" value="{{ c.card.id }}"><button name="action" value="restore">restore</button></form>

      {% else if can_edit %}

        <button name="action" value="move">move</button><button name="action" value="up" aria-label="Up">↑</button><button name="action" value="down" aria-label="Down">↓</button><button name="action" value="archive" title="Archive: off the board, kept and restorable">archive</button><button name="action" value="remove" aria-label="Remove from the project" title="Remove from the project">✕</button>

  {% if can_edit && !archived %}

    <form class="col-archive" method="post" action="/projects/{{ project.owner }}/{{ project.number }}"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="column" value="{{ col.column.id }}">

      <label for="older-{{ col.column.id }}">Archive cards here more than</label>

      <div class="inline-fields"><input type="number" id="older-{{ col.column.id }}" name="days" min="0" max="3650" value="14" required><span class="small mute">days</span><button name="action" value="archive_older" class="small">ARCHIVE</button></div>

    </form>

    <form class="col-archive" method="post" action="/projects/{{ project.owner }}/{{ project.number }}"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="column" value="{{ col.column.id }}">

      <label for="after-{{ col.column.id }}">Archive automatically after</label>

      <div class="inline-fields"><input type="number" id="after-{{ col.column.id }}" name="days" min="0" max="3650" placeholder="never"{% if let Some(d) = col.column.archive_after_days %} value="{{ d }}"{% endif %}><span class="small mute">days</span><button name="action" value="archive_after" class="small">SAVE</button></div>

    </form>

{% if can_edit && !archived %}

.col-archives { margin: 0 0 6px; }

.board-archived-link { margin-left: auto; }

.col-archive { margin-top: 8px; }

.col-archive .inline-fields { align-items: center; }

.col-archive input[type=number] { width: 6em; margin: 0; }