pull: bring a working copy that fell behind up to its bookmark f6dccc4533c8

- **`pull` brings a working copy that fell behind up to its bookmark (#89).** The working copy followed a pull only from exactly the bookmark's old heads, and not at all when the pull brought nothing new, so one left behind by `bookmark set`, a landing or a pull from another workspace stayed on old code while `status` said clean. It now follows whenever its base is part of the bookmark's state, clean or carrying uncommitted work, and `status` says when the working copy is behind its bookmark and by how many changes.

        if changed || !others.is_empty() {

            self.record_op(&[op_ref], &format!("oxy pull {remote_name}"), view)?;

        // The working copy follows its bookmark whenever nothing would be

        // lost, also when this pull brought nothing new but it had been

        // left behind (oxygen#89).

        let checked_out = self.follow_bookmark(&current_heads, &current, "oxy pull")?;

            heads: if changed {

                current_heads

            } else {

                local_current

            },

    }

    /// How many changes the working copy's bookmark has that its base

    /// lacks, when the base is part of the bookmark's state (it fell behind,

    /// and `oxy checkout` or `oxy pull` brings it up); `None` when it is on

    /// the bookmark or holds changes the bookmark lacks. History is read

    /// only when the base and the bookmark's heads differ (oxygen#89).

    pub fn working_copy_behind(&self) -> Result<Option<usize>> {

        let (_, wc) = self.working_copy()?;

        let mut base = wc.deps.clone();

        base.sort();

        let mut heads = self.bookmark_heads()?;

        heads.sort();

        if base == heads || heads.is_empty() {

            return Ok(None);

        }

        let state = self.load_state_history(&heads)?;

        if !base.iter().all(|h| state.contains(h)) {

            return Ok(None);

        }

        let had = if base.is_empty() {

            0

        } else {

            self.load_state_history(&base)?.len()

        };

        Ok(Some(state.len().saturating_sub(had)).filter(|n| *n > 0))

    }

    /// Bring the working copy to `heads`, the state of its bookmark

    /// `bookmark`, when nothing would be lost: its base is part of that

    /// state, so the bookmark only adds to it. Clean, it is checked out;

    /// with uncommitted work, the work comes along when the new changes

    /// leave its paths alone (as `git pull` does), else it stays. Before,

    /// it followed only from exactly the bookmark's old heads, so a working

    /// copy already behind (the bookmark moved by `bookmark set`, a landing

    /// or a pull from another workspace) never caught up, and nothing said

    /// so (oxygen#74, #89). Returns whether it moved.

    pub fn follow_bookmark(

        &self,

        heads: &[ChangeHash],

        bookmark: &str,

        command: &str,

    ) -> Result<bool> {

        let snap = self.snapshot(command)?;

        let clean = snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty();

        let mut base = snap.base.maximal(&snap.wc.deps);

        base.sort();

        let mut target = heads.to_vec();

        target.sort();

        if base == target {

            return Ok(false);

        }

        let state = self.load_state_history(heads)?;

        if !base.iter().all(|h| state.contains(h)) {

            // The working copy holds changes the bookmark lacks: not ours to move.

            return Ok(false);

        }

        if clean {

            self.checkout(heads, false, &format!("{command} (checkout)"))?;

            Ok(true)

        } else {

            Ok(self

                .checkout_carry(heads, bookmark, &format!("{command} (checkout --carry)"))

                .is_ok())

        }

#[test]

fn a_working_copy_behind_its_bookmark_is_flagged_and_pull_brings_it_up() {

    // oxygen#89 (supermarioland, 2026-10-09): the bookmark moved on without

    // the working copy, a pull with nothing new left it there, and status

    // said "clean".

    hermetic();

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

    let root = dir.path();

    let _up = Repo::init(&root.join("up")).unwrap();

    let url = root.join("up").to_string_lossy().to_string();

    let other = Repo::clone(&url, &root.join("other"))

        .unwrap()

        .with_home(root.join("home"));

    write(&root.join("other"), "a.txt", b"a\n");

    other.commit("a", &[]).unwrap();

    assert!(other.push("origin", false).unwrap()[0].ok);

    let one = Repo::clone(&url, &root.join("one"))

        .unwrap()

        .with_home(root.join("home"));

    write(&root.join("other"), "b.txt", b"b\n");

    other.commit("b", &[]).unwrap();

    assert!(other.push("origin", false).unwrap()[0].ok);

    one.fetch("origin").unwrap();

    // The bookmark moves; the working copy does not.

    let theirs = one.resolve_heads("origin/main").unwrap();

    one.bookmark_set("main", &theirs).unwrap();

    assert!(!root.join("one/b.txt").exists());

    assert_eq!(one.working_copy_behind().unwrap(), Some(1));

    let r = one.pull("origin").unwrap();

    assert!(

        !r.changed && r.checked_out,

        "nothing new, but the working copy caught up"

    );

    assert!(root.join("one/b.txt").exists());

    assert_eq!(one.working_copy_behind().unwrap(), None);

}

  otherwise it stays and `oxy checkout` updates it. A working copy that had

  fallen behind its bookmark catches up on the next pull too, and `oxy

  status` says when it is behind.

            "{} {}{}",

            )),

            if r.checked_out {

                ui::dim(" The working copy had fallen behind it and is updated.")

            } else {

                String::new()

            }

        if r.checked_out {

            super::workspace::where_now(&repo);

        }

/// Say when the working copy has fallen behind its own bookmark: a

/// "clean" status there hid a pull that left it on old code (oxygen#89).

fn print_behind(repo: &Repo) {

    if let Ok(Some(n)) = repo.working_copy_behind() {

        println!(

            "  {} {}",

            ui::caution(),

            ui::warn(format!(

                "the working copy is behind {}: it lacks {} the bookmark has; oxy checkout brings it up",

                repo.config.bookmark,

                plural(n, "change")

            ))

        );

    }

}

        print_behind(&repo);

    print_behind(&repo);