Boards keep the last fortnight of finished work (refs #293) 946fe7a09faa

- **Boards keep the last fortnight of finished work (#293):** by default every column archives its finished cards (closed issues, closed or landed proposals) 14 days after they reached it, hourly, so a Done column stops growing however long a project runs; open work and notes stay. A column can instead archive every card after N days, or never ("Archive automatically" in its menu). Archived cards stay on the board's archive view, searchable and restorable. On the next hourly pass, boards with years of Done cards (Super Mario Land 2's 327) shrink to their last two weeks.

/// Archive a column's cards this many days after they join it; `None`

/// finished cards after [`FINISHED_KEPT_DAYS`] (the default); [`NEVER`]

/// none.

/// Days after which a column with no setting of its own archives its

/// finished cards (#293): a board shows the last fortnight's done work.

pub const FINISHED_KEPT_DAYS: i64 = 14;

/// A column's `archive_after_days` that means never.

pub const NEVER: i64 = -1;

/// Archive, on every board, the cards their columns keep no longer (#293);

/// how many. A column that archives after N days: every card that joined it

/// longer ago. A column with no setting: finished cards (a closed issue, a

/// closed or landed proposal) after [`FINISHED_KEPT_DAYS`], so a Done column

/// stops growing while open work and notes stay. [`NEVER`]: none.

    let set = sqlx::query(

         (SELECT 1 FROM project_columns c WHERE c.id = project_cards.column_id AND c.archive_after_days >= 0 \

    .execute(pool)

    .await?;

    let finished = sqlx::query(

        "UPDATE project_cards SET archived_ms = $1 WHERE archived_ms IS NULL AND moved_ms < $2 \

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

         AND ((kind = 'issue' AND EXISTS (SELECT 1 FROM issues i WHERE i.repo_id = project_cards.repo_id \

               AND i.number = project_cards.number AND i.state = 'closed')) \

           OR (kind = 'proposal' AND EXISTS (SELECT 1 FROM proposals p WHERE p.repo_id = project_cards.repo_id \

               AND p.number = project_cards.number AND p.state IN ('closed', 'landed'))))",

    )

    .bind(now)

    .bind(now - FINISHED_KEPT_DAYS * DAY_MS)

    Ok(set.rows_affected() + finished.rows_affected())

    /// Its cards are all finished work (a Done column): its note says

    /// they are archived after a fortnight unless it says otherwise.

    pub finished: bool,

        let items: Vec<&CardView> = views.iter().filter(|v| v.card.kind != "note").collect();

        let finished = !items.is_empty() && items.iter().all(|v| matches!(v.state.as_str(), "closed" | "landed"));

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

    /// Automatic archiving: `finished` (the default), `days` or `never`.

    mode: String,

    #[serde(default)]

            let days = match (f.action.as_str(), f.mode.as_str(), f.days.trim()) {

                ("archive_after", "finished", _) | ("archive_after", "", "") => None,

                ("archive_after", "never", _) => Some(pdb::NEVER),

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

                    Some(pdb::NEVER) => format!("{name} keeps its cards until you archive them."),

                    None => format!("{name} archives finished cards {} days after they reach it.", pdb::FINISHED_KEPT_DAYS),

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

    // The default (#293, Andy 2026-10-25): finished work, a closed issue,

    // goes a fortnight after it reached its column; open work and notes stay.

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

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

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

    let repo = db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();

    let mut cards = vec![];

    for title in ["shipped", "still open"] {

        let i = db::issues::create(&app.db, db::issues::NewIssue { repo_id: repo.id, title, body: "", author_id: None, author: "andy" })

            .await

            .unwrap();

        if title == "shipped" {

            db::issues::set_state(&app.db, i.id, "closed", "completed").await.unwrap();

        }

        let id: i64 = sqlx::query_scalar(

            "INSERT INTO project_cards (project_id, column_id, position, kind, repo_id, number, note, created_ms, moved_ms) \

             VALUES ($1, $2, 10, 'issue', $3, $4, '', 0, $5) RETURNING id",

        )

        .bind(project)

        .bind(done)

        .bind(repo.id)

        .bind(i.number)

        .bind(now - 20 * day)

        .fetch_one(&app.db)

        .await

        .unwrap();

        cards.push(id);

    }

    assert_eq!(db::projects::archive_due(&app.db, db::now_ms()).await.unwrap(), 1, "the closed issue only");

    let archived_ms = |id: i64| async move {

        sqlx::query_scalar::<_, Option<i64>>("SELECT archived_ms FROM project_cards WHERE id = $1")

            .bind(id)

            .fetch_one(&app.db)

            .await

            .unwrap()

    };

    assert!(archived_ms(cards[0]).await.is_some() && archived_ms(cards[1]).await.is_none());

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

    assert!(page.contains("value=\"finished\" selected"), "the column says so");

- 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 on its own (checked hourly): by default its finished cards (closed issues, closed or landed proposals) 14 days after they reached it, so a Done column shows the last fortnight's work and an ongoing project's board stays its size; or every card after N days; or never. Open work and notes are never archived by the default. An issue's or proposal's page says when its card is archived.

  {% if !archived %}{% match col.column.archive_after_days %}{% when Some(-1) %}{% when Some(d) %}<p class="small mute col-archives">archives cards {{ d }} day{% if *d != 1 %}s{% endif %} after they reach it</p>{% when None %}{% if col.finished %}<p class="small mute col-archives">finished cards are archived after {{ crate::db::projects::FINISHED_KEPT_DAYS }} days</p>{% endif %}{% endmatch %}{% endif %}

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

      <div class="inline-fields"><select id="mode-{{ col.column.id }}" name="mode" aria-label="Archive automatically"><option value="finished"{% if col.column.archive_after_days.is_none() %} selected{% endif %}>finished cards after {{ crate::db::projects::FINISHED_KEPT_DAYS }} days</option><option value="days"{% if col.column.archive_after_days.unwrap_or(-1) >= 0 %} selected{% endif %}>every card after</option><option value="never"{% if col.column.archive_after_days == Some(-1) %} selected{% endif %}>never</option></select><input type="number" id="after-{{ col.column.id }}" name="days" min="0" max="3650" placeholder="days" aria-label="Days"{% if let Some(d) = col.column.archive_after_days %}{% if *d >= 0 %} value="{{ d }}"{% endif %}{% endif %}><button name="action" value="archive_after" class="small">SAVE</button></div>