When a proposal's target moves, its new projected state is run d943160dafeb

        let number = p.number;

            } else if l.row.is_open() && !l.hashes.is_empty() && crate::flow::enabled(app, row) {

                // The target moved, so the proposal's projected state is

                // new and its checks would be for an older one (#134): run

                // the pipeline on it, once.

                let ran: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM flow_runs WHERE repo_id = ? AND state = ?")

                    .bind(row.id)

                    .bind(&l.state)

                    .fetch_one(&app.db)

                    .await

                    .unwrap_or(1);

                if ran == 0 {

                    let label = format!("proposal/{number}");

                    match crate::flow::start_run_scoped(app, row, &label, &l.state, &l.heads, actor, "proposal", None).await {

                        Ok(Some(n)) => tracing::info!("proposal {number}: its target moved; run #{n} checks its new projected state"),

                        Ok(None) => {}

                        Err(e) => tracing::warn!("proposal {number}: a run of its new projected state did not start: {e}"),

                    }

                }

    // The target moved: its other open proposals are checked again (#134).

    settle_after_push(app, row, &p.target, &me.username).await;

/// #134: when a proposal's target moves, its projected state is new; the

/// hub runs the pipeline on it, so its checks are never for an older one.

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

async fn a_moved_target_runs_its_open_proposals_again() {

    let h = hub().await;

    db::accounts::create_account(&h.app.db, "andy", "[email protected]", "x", "salt", true).await.unwrap();

    create(&h.app, "andy", "demo").await;

    let work = tempfile::tempdir().unwrap();

    let mut c = client(&format!("{}/andy/demo", h.base), work.path());

    write(work.path(), ".flow/pipeline.kdl", &pipeline(""));

    write(work.path(), "test.sh", "echo ok\n");

    c.snapshot("t").unwrap();

    let base = c.commit("base", &[]).unwrap();

    assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

    // Two proposals, each main plus one change.

    for (b, file) in [("fix-a", "a.txt"), ("fix-b", "b.txt")] {

        c.bookmark_create(b, Some(&[base])).unwrap();

        c.bookmark_switch(b, true).unwrap();

        write(work.path(), file, "x\n");

        c.snapshot("t").unwrap();

        c.commit(&format!("add {file}"), &[]).unwrap();

        assert!(c.push_bookmark("origin", b, false).unwrap().iter().all(|r| r.ok));

        let body = serde_json::json!({ "title": b, "target": "main", "source": b }).to_string();

        let (st, out) = call(&h.app, "POST", "/api/v1/repos/andy/demo/proposals", Some("site"), Some(body)).await;

        assert_eq!(st, StatusCode::CREATED, "{out}");

    }

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

    let props = db::proposals::list(&h.app.db, row.id, &["open"]).await.unwrap();

    let a = props.iter().find(|p| p.source_bookmark == "fix-a").unwrap().number;

    let b = props.iter().find(|p| p.source_bookmark == "fix-b").unwrap().number;

    // Landing fix-a moves main: fix-b's projected state gets a run.

    let (st, out) = call(&h.app, "POST", &format!("/api/v1/repos/andy/demo/proposals/{a}/land"), Some("site"), Some("{}".into())).await;

    assert_eq!(st, StatusCode::OK, "{out}");

    let label = format!("proposal/{b}");

    let mut found = None;

    for _ in 0..100 {

        if let Some(r) = runs_of(&h.app, "andy", "demo").await.into_iter().find(|r| r.bookmark == label) {

            found = Some(r);

            break;

        }

        tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    }

    let run = found.expect("a run of fix-b's new projected state");

    let projected = db::proposals::get(&h.app.db, row.id, b).await.unwrap().unwrap();

    assert_eq!((run.trigger.as_str(), run.state.as_str()), ("proposal", projected.projected_state.as_str()), "on its projected state");

    // Moving main again by a push does it once more; the same state is not run twice.

    let before = runs_of(&h.app, "andy", "demo").await.len();

    oxygenhub::web::proposals::settle_after_push(&h.app, &row, "main", "andy").await;

    assert_eq!(runs_of(&h.app, "andy", "demo").await.len(), before, "not again for the same state");

}

When a proposal's target moves (a push, or another proposal landing), its projected state is new and its checks would be for the old one: the hub starts a run of the pipeline on each open proposal's new projected state, labelled `proposal/N` with the trigger `proposal`, unless that state has been run already (#134). Its author, or anyone with triage access, closes and reopens a proposal on its page or with `PATCH /api/v1/repos/{o}/{n}/proposals/{number}` and `{"state": "closed"}` or `{"state": "open"}` (`oh proposal close N [-m MSG]`, `oh proposal reopen N`; #140); asking for the state it already has changes nothing, and landing has its own endpoint. The author or a writer can **ask for a review** from anyone who can read the repository (not the author), under Reviewers on the proposal page or with `POST /api/v1/repos/{o}/{n}/proposals/{number}/reviewers` and `{"reviewers": [...]}`; `DELETE .../reviewers/{username}` withdraws a request. Each person asked gets a notification (`proposal.review_requested`), the timeline records it, the proposal's JSON lists `requested_reviewers`, and a review from that person answers the request. Every review notifies the proposal's author (`proposal.review`). An AI assistant the repository may use (§13.4) can be asked the same way; its answer is a `comment` review recorded via the assistant under the asker's name.