Load history only where no file graph is needed 57eaac9107df

            return fail(format!("bookmark {name} already exists"));

        }

        let heads = match heads {

            None => {

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

            }

        };

        let mut view = op.view.clone();

                "no bookmark {name}; create it with `oxy bookmark create`"

            ));

        }

        let mut view = op.view.clone();

        view.bookmarks.insert(

            name.to_string(),

        let local = self.heads_of(&op.view, &current)?;

        let mut all = local.clone();

        all.extend(other);

        heads.sort();

        let mut sorted_local = local.clone();

        sorted_local.sort();

        let Ok(heads) = self.bookmark_heads() else {

            return;

        };

            return;

        };

        let view = state.tree().view();

            out

        };

        let candidates = replace(&heads);

        let new_heads = st.maximal(&candidates);

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

        let wc_base = base.maximal(&wc.deps);

        let wc_base = if wc_base.contains(old) {

            let c = replace(&wc_base);

            st.maximal(&c)

        } else {

            wc_base

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

        let mut all = heads.clone();

        all.push(wc_hash);

        if !state.closure(&wc_hash).contains(old)

            && !heads.contains(old)

            && !state.heads().contains(old)

            out

        };

        let candidates = remap(&heads);

        let new_heads = st.maximal(&candidates);

        let new_wc = mapping.get(&wc_hash).copied().unwrap_or(wc_hash);

            return fail("that is the working copy; commit it instead");

        }

        // Every reference must live in the target's closure (or be the target).

        let ok_change = |h: &ChangeHash| *h == *target || closure.contains(h);

        let ok_node = |n: &NodeId| n.is_root() || closure.tree().introducer(n).is_some();

        let too_new = |what: &str| {

        let bookmark = self.config.bookmark.clone();

        let mut heads = self.heads_of(&op.view, &bookmark)?;

        heads.push(h);

        let heads = st.maximal(&heads);

        let mut view = op.view.clone();

        view.bookmarks.insert(

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

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

        base.push(h);

        let fresh = self.new_working_copy(wc_base, &wc.message);

        view.workspaces

            .insert(self.workspace, self.store.put_change(&fresh)?);

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

        let mut all = heads.clone();

        all.push(wc_hash);

        for (h, meta) in state.changes() {

            if !meta.deps.contains(hash) {

                continue;

        if dst.kind == ChangeKind::WorkingCopy {

            return fail("cannot squash into the working copy");

        }

        let outside: Vec<String> = src

            .deps

            .iter()

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

        let mut all = self.bookmark_heads()?;

        all.push(wc_hash);

        let src_now = state

            .changes()

            .find(|(_, m)| m.change_id == src.change_id)

            return fail("no identity: run oxy identity create");

        };

        let heads = self.bookmark_heads()?;

        let mut out = Vec::new();

        for (h, meta) in state.changes() {

            if (meta.author == key || meta.author.is_zero())

            return fail("a bisect is in progress; finish it or run `oxy bisect reset`");

        }

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

        self.bisect_save(&BisectState {

            start,

            ..Default::default()

    fn bisect_heads(&self, st: &BisectState, k: usize) -> Vec<ChangeHash> {

        let mut all = st.good.clone();

        all.extend(st.candidates[..k].iter().copied());

            .map(|s| s.maximal(&all))

            .unwrap_or(all)

    }

                    bad: st.bad.len(),

                });

            }

            st.good = good_heads.clone();

            st.bad = bad_heads.clone();

            st.candidates = self.negotiate(&good_heads, &bad_heads)?;

        let remote_heads = self.store.get_state(&remote_state)?.heads;

        let mut all = local.clone();

        all.extend(remote_heads);

        let mut heads = st.maximal(&all);

        heads.sort();

        let mut sorted_local = local.clone();

        if op.view.tags.contains_key(name) {

            return fail(format!("tag {name:?} already exists; tags are immutable"));

        }

        let heads = st.maximal(heads);

        if heads.is_empty() {

            return fail("a tag needs at least one change");