History editing: oxy amend --into folds the working copy into an older change with dependents rewritten; oxy split; graph: delete/insert conflicts only between commuting changes (spec 0.6l) 23b217d75848

        // A deleted atom is a ghost when a live direct successor was inserted

        // by a change that commutes with every deleter: neither depends on

        // the other (spec §9.1, delete/insert). If the inserter came after the

        // deletion, or the deleter saw the insertion, there is no conflict.

                Vertex::Atom(y) if self.is_live(y) => !info.deleted_by.iter().any(|d| deps.depends_on(d, &y.0) || deps.depends_on(&y.0, d)),

    fn insert_after_a_line_deleted_by_a_dependency_is_not_a_conflict() {

        // 1 inserts a,b; 2 deletes b (depends on 1); 3 depends on 2 yet anchors

        // after the dead b (a rewritten change may do this): no conflict.

        let mut g = FileGraph::new();

        g.insert(h(1), 0, Vertex::Start, Vertex::End, &lines(&["a\n", "b\n"]));

        g.delete(h(2), &AtomRange { change: h(1), from: 1, to: 2 });

        g.insert(h(3), 0, Vertex::Atom((h(1), 1)), Vertex::End, &lines(&["c\n"]));

        let deps = Deps([(h(2), vec![h(1)]), (h(3), vec![h(2)])].into_iter().collect());

        let m = g.materialize(&deps);

        assert!(!m.is_conflicted(), "{:?}", m.segments);

        assert_eq!(text(&g, &m), "a\nc\n");

        // A change that deletes a line it introduced itself, with a dependent

        // anchoring after it, is likewise fine.

        let mut g = FileGraph::new();

        g.insert(h(1), 0, Vertex::Start, Vertex::End, &lines(&["x\n"]));

        g.delete(h(1), &AtomRange { change: h(1), from: 0, to: 1 });

        g.insert(h(2), 0, Vertex::Atom((h(1), 0)), Vertex::End, &lines(&["y\n"]));

        let deps = Deps([(h(2), vec![h(1)])].into_iter().collect());

        let m = g.materialize(&deps);

        assert!(!m.is_conflicted());

        assert_eq!(text(&g, &m), "y\n");

    }

    #[test]

use crate::objects::{AtomRange, AtomRef};

/// Translate a reference to change `target`'s own atom or op into a self

/// reference, and a working-copy self reference into one offset past the

/// target's own count; other references pass through.

fn fold_atom(r: AtomRef, target: &ChangeHash, wc_offset: &HashMap<NodeId, u32>, node: &NodeId) -> Option<AtomRef> {

    match r {

        AtomRef::Atom { change, index } if change == *target => Some(AtomRef::Atom { change: ObjectRef::ZERO, index }),

        AtomRef::Atom { change, index } if change.is_zero() => Some(AtomRef::Atom { change: ObjectRef::ZERO, index: index + wc_offset.get(node).copied().unwrap_or(0) }),

        // References into the target's closure were validated by the caller and stay as they are.

        other => Some(other),

    }

}

impl Repo {

    /// Fold the working copy's uncommitted edits into any change of the

    /// bookmark (spec §8.4). The edits must reference only atoms, placements

    /// and nodes that exist in the target's own closure; dependents are

    /// rewritten with an identity correspondence, since the target's own

    /// atoms keep their indices.

    pub fn amend_into(&self, target: &ChangeHash, message: Option<&str>) -> Result<ChangeHash> {

        let snap = self.snapshot("oxy amend")?;

        if snap.statuses.iter().any(|s| s.status == ChangeStatus::ConflictEdited) {

            return fail("a file still contains conflict markers");

        }

        let wc = &snap.wc;

        if wc.tree_ops.is_empty() && wc.edits.is_empty() && message.is_none() {

            return fail("nothing to amend: the working copy is clean and no new message was given");

        }

        let old = self.store.get_change(target)?;

        if old.kind == ChangeKind::WorkingCopy {

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

        }

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

        let closure = self.load_state(&[*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| RepoError::Msg(format!("{what} was introduced after change #{}; amend into a later change instead", target.short(12)));

        for op in &wc.tree_ops {

            match op {

                TreeOp::AddNode { parent, .. } => {

                    if !ok_node(parent) {

                        return Err(too_new("the parent directory"));

                    }

                }

                TreeOp::RemoveNode { node, placement } => {

                    if !ok_node(node) || !ok_change(&placement.change) {

                        return Err(too_new("a removed file"));

                    }

                }

                TreeOp::Move { node, old, parent, .. } => {

                    if !ok_node(node) || !ok_change(&old.change) || !ok_node(parent) {

                        return Err(too_new("a moved file"));

                    }

                }

                TreeOp::SetMode { node, old, .. } => {

                    if !ok_node(node) || !ok_change(&old.change) {

                        return Err(too_new("a file whose mode changed"));

                    }

                }

            }

        }

        let wc_added: BTreeSet<NodeId> = wc.tree_ops.iter().filter_map(|o| if let TreeOp::AddNode { node, .. } = o { Some(*node) } else { None }).collect();

        for e in &wc.edits {

            let n = e.node();

            if !wc_added.contains(&n) && !ok_node(&n) {

                return Err(too_new("an edited file"));

            }

            let refs: Vec<ChangeHash> = match e {

                Edit::Insert { after, before, .. } => [after, before].iter().filter_map(|r| if let AtomRef::Atom { change, .. } = r { Some(*change) } else { None }).collect(),

                Edit::Delete { atoms, .. } => atoms.iter().map(|r| r.change).collect(),

                Edit::Replace { .. } => vec![],

            };

            if refs.iter().any(|h| !h.is_zero() && !ok_change(h)) {

                return Err(too_new("an edited line"));

            }

        }

        // Compose: the target's operations first, then the working copy's

        // with references to the target turned into self references and its

        // own atom indices shifted past the target's.

        let mut per_node: HashMap<NodeId, u32> = HashMap::new();

        for e in &old.edits {

            if let Edit::Insert { node, lines, .. } = e {

                *per_node.entry(*node).or_default() += lines.len() as u32;

            }

        }

        let op_offset = old.tree_ops.len() as u32;

        let fold_op = |r: OpRef| -> OpRef {

            if r.change == *target {

                OpRef { change: ObjectRef::ZERO, index: r.index }

            } else if r.change.is_zero() {

                OpRef { change: ObjectRef::ZERO, index: r.index + op_offset }

            } else {

                r

            }

        };

        let mut tree_ops = old.tree_ops.clone();

        for op in &wc.tree_ops {

            tree_ops.push(match op {

                TreeOp::RemoveNode { node, placement } => TreeOp::RemoveNode { node: *node, placement: fold_op(*placement) },

                TreeOp::Move { node, old, parent, name } => TreeOp::Move { node: *node, old: fold_op(*old), parent: *parent, name: name.clone() },

                TreeOp::SetMode { node, old, mode } => TreeOp::SetMode { node: *node, old: fold_op(*old), mode: *mode },

                add => add.clone(),

            });

        }

        let mut edits = old.edits.clone();

        for e in &wc.edits {

            edits.push(match e {

                Edit::Insert { node, after, before, lines } => Edit::Insert {

                    node: *node,

                    after: fold_atom(*after, target, &per_node, node).ok_or_else(|| too_new("an anchor line"))?,

                    before: fold_atom(*before, target, &per_node, node).ok_or_else(|| too_new("an anchor line"))?,

                    lines: lines.clone(),

                },

                Edit::Delete { node, atoms } => Edit::Delete {

                    node: *node,

                    atoms: atoms

                        .iter()

                        .map(|r| {

                            if r.change == *target {

                                AtomRange { change: ObjectRef::ZERO, from: r.from, to: r.to }

                            } else if r.change.is_zero() {

                                let off = per_node.get(node).copied().unwrap_or(0);

                                AtomRange { change: ObjectRef::ZERO, from: r.from + off, to: r.to + off }

                            } else {

                                *r

                            }

                        })

                        .collect(),

                },

                other => other.clone(),

            });

        }

        let mut new = Change {

            change_id: old.change_id,

            deps: vec![],

            author: self.author(),

            hlc: Hlc::now(),

            message: message.map(|m| m.trim_end().to_string()).unwrap_or(old.message.clone()),

            tree_ops,

            edits,

            kind: old.kind,

        };

        let beneath = self.load_state(&old.deps)?;

        let mut deps: BTreeSet<ChangeHash> = old.deps.iter().copied().collect();

        deps.extend(referenced_changes(&new, &beneath).into_iter().filter(|h| *h != *target));

        deps.extend(wc.deps.iter().filter(|d| closure.contains(d) && **d != *target).copied());

        new.deps = deps.into_iter().collect();

        new.normalize();

        // Rewrite dependents (identity correspondence), then start a fresh,

        // empty working copy: its edits now live in the amended change.

        let corr = Correspondence::identity(&old);

        let new_hash = self.rewrite_change(target, Some(&new), &corr, &format!("oxy amend --into {}", old.change_id.short(8)))?.unwrap();

        let (op_ref, op) = self.head_op()?;

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

        let fresh = self.new_working_copy(heads, "");

        let wc_hash = self.store.put_change(&fresh)?;

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

        view.workspaces.insert(self.workspace, wc_hash);

        self.record_op(&[op_ref], "oxy amend (working copy)", view)?;

        self.drop_manifest();

        Ok(new_hash)

    }

    /// Split a head into two changes: one holding the head's effect on

    /// `paths`, the other the rest (keeping the head's ChangeId). The

    /// working copy is unaffected.

    pub fn split(&self, hash: &ChangeHash, paths: &[String]) -> Result<(ChangeHash, ChangeHash)> {

        let old = self.rewritable_head(hash)?;

        if paths.is_empty() {

            return fail("name at least one path to split out");

        }

        let beneath = self.load_state(&old.deps)?;

        let beneath_snapshot = beneath.materialize();

        let full = self.load_state(&[*hash])?;

        let full_snapshot = full.materialize();

        let selected = |p: &str| paths.iter().any(|x| p == x || p.starts_with(&format!("{}/", x.trim_end_matches('/'))));

        // Entries of the intermediate state: selected paths as the head

        // leaves them, everything else as beneath.

        let entries_of = |snap: &Snapshot, keep_from_full: &dyn Fn(&str) -> bool| -> Result<BTreeMap<String, FsEntry>> {

            let mut out = BTreeMap::new();

            for (p, _) in snap.files.iter().chain(full_snapshot.files.iter()) {

                let take_full = keep_from_full(p);

                let src = if take_full { full_snapshot.files.get(p) } else { snap.files.get(p) };

                let Some(src) = src else { continue };

                if out.contains_key(p) {

                    continue;

                }

                let content = match &src.content {

                    FileContent::Dir => continue,

                    FileContent::Text { bytes, .. } => bytes.clone(),

                    FileContent::Opaque { blobs } => match blobs.first() {

                        Some(b) => self.read_blob(b)?,

                        None => continue,

                    },

                };

                out.insert(p.clone(), FsEntry { kind: src.kind, exec: src.mode.exec, content });

            }

            Ok(out)

        };

        let mid_entries = entries_of(&beneath_snapshot, &|p| selected(p))?;

        let first = self.build_from_entries(&beneath, &beneath_snapshot, HashMap::new(), &mid_entries)?;

        if first.tree_ops.is_empty() && first.edits.is_empty() {

            return fail("the named paths are not touched by that change");

        }

        let mut c1 = Change {

            change_id: ChangeId::random(),

            deps: old.deps.clone(),

            author: old.author,

            hlc: Hlc::now(),

            message: format!("{} (part 1: {})", old.message.lines().next().unwrap_or(""), paths.join(", ")),

            tree_ops: first.tree_ops,

            edits: first.edits,

            kind: ChangeKind::Normal,

        };

        let mut d1: BTreeSet<ChangeHash> = referenced_changes(&c1, &beneath);

        d1.extend(old.deps.iter().copied());

        c1.deps = d1.into_iter().collect();

        c1.normalize();

        let h1 = self.store_signed(&c1)?;

        let mut mid = beneath.clone();

        mid.add(c1)?;

        let mid_snapshot = mid.materialize();

        let rest_entries = entries_of(&full_snapshot, &|_| true)?;

        let rest = self.build_from_entries(&mid, &mid_snapshot, HashMap::new(), &rest_entries)?;

        if rest.tree_ops.is_empty() && rest.edits.is_empty() {

            return fail("everything in that change is under the named paths; nothing would remain");

        }

        let mut c2 = Change {

            change_id: old.change_id,

            deps: vec![],

            author: old.author,

            hlc: Hlc::now(),

            message: old.message.clone(),

            tree_ops: rest.tree_ops,

            edits: rest.edits,

            kind: ChangeKind::Normal,

        };

        let mut d2: BTreeSet<ChangeHash> = referenced_changes(&c2, &mid);

        d2.extend(old.deps.iter().copied());

        c2.deps = d2.into_iter().collect();

        c2.normalize();

        let h2 = self.replace_head(hash, Some(&c2), &format!("oxy split {} {}", old.change_id.short(8), paths.join(" ")))?.unwrap();

        // c1 may be a head of its own if c2 does not depend on it.

        let (op_ref, op) = self.head_op()?;

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

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

        heads.push(h1);

        let st = self.load_state(&heads)?;

        let heads = st.maximal(&heads);

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

        view.bookmarks.insert(bookmark, self.store.put_state(&StateObject::new(heads.clone()))?);

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

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

        base.push(h1);

        let wc_base = self.load_state(&base)?.maximal(&base);

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

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

        self.record_op(&[op_ref], "oxy split (heads)", view)?;

        self.drop_manifest();

        Ok((h1, h2))

    }

}

#[test]

fn amend_into_older_change_and_split() {

    hermetic();

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

    let root = dir.path();

    let mut repo = Repo::init(root).unwrap().with_home(root.join("home"));

    repo.create_identity("Ada", "a@b", IdentityScope::User).unwrap();

    repo.set_user_config("core.sign", "change").unwrap();

    write(root, "a.txt", b"one\ntwo\n");

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

    write(root, "a.txt", b"one\nTWO\n");

    let h1 = repo.commit("edit two", &[]).unwrap();

    write(root, "a.txt", b"one\nTWO\nthree\n");

    let h2 = repo.commit("add three", &[]).unwrap();

    let id1 = repo.store().get_change(&h1).unwrap().change_id;

    // Fixing the line h1 introduced folds into h1; h2 is rewritten on top.

    write(root, "a.txt", b"one\nTWO!\nthree\n");

    let h1b = repo.amend_into(&h1, None).unwrap();

    assert_ne!(h1b, h1);

    let c1b = repo.store().get_change(&h1b).unwrap();

    assert_eq!(c1b.change_id, id1);

    assert_eq!(c1b.deps, vec![h0]);

    assert!(matches!(repo.verify_change(&h1b).unwrap(), SignatureStatus::Valid { .. }));

    let heads = repo.bookmark_heads().unwrap();

    assert_eq!(heads.len(), 1);

    let top = repo.store().get_change(&heads[0]).unwrap();

    assert_eq!(top.message, "add three");

    assert_eq!(top.deps.iter().copied().collect::<BTreeSet<_>>(), [h0, h1b].into_iter().collect(), "depends on the file's creator and the rewritten line");

    let snap = repo.load_state(&heads).unwrap().materialize();

    assert!(matches!(&snap.files["a.txt"].content, FileContent::Text { bytes, .. } if bytes == b"one\nTWO!\nthree\n"));

    assert!(!repo.snapshot("status").unwrap().changed, "the working copy is clean after folding");

    // Only h1b's own state shows the fix without "three".

    let only = repo.load_state(&[h1b]).unwrap().materialize();

    assert!(matches!(&only.files["a.txt"].content, FileContent::Text { bytes, .. } if bytes == b"one\nTWO!\n"));

    assert_eq!(repo.log().unwrap().len(), 4);

    // An edit to a line introduced by h2 cannot fold into h1.

    write(root, "a.txt", b"one\nTWO!\nthree!\n");

    let err = repo.amend_into(&h1b, None).unwrap_err().to_string();

    assert!(err.contains("introduced after"), "{err}");

    assert!(repo.snapshot("status").unwrap().statuses.len() == 1, "nothing was changed by the refusal");

    write(root, "a.txt", b"one\nTWO!\nthree\n");

    // Split the head that touches two files.

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

    write(root, "c.txt", b"c\n");

    let h3 = repo.commit("b and c", &[]).unwrap();

    let id3 = repo.store().get_change(&h3).unwrap().change_id;

    let (p1, p2) = repo.split(&h3, &["b.txt".into()]).unwrap();

    let c_1 = repo.store().get_change(&p1).unwrap();

    let c_2 = repo.store().get_change(&p2).unwrap();

    assert!(c_1.message.contains("part 1: b.txt"));

    assert_eq!(c_2.change_id, id3);

    let heads: BTreeSet<_> = repo.bookmark_heads().unwrap().into_iter().collect();

    assert!(heads.contains(&p1) && heads.contains(&p2), "independent parts are both heads");

    let snap = repo.load_state(&repo.bookmark_heads().unwrap()).unwrap().materialize();

    assert!(snap.files.contains_key("b.txt") && snap.files.contains_key("c.txt"));

    let only1 = repo.load_state(&[p1]).unwrap().materialize();

    assert!(only1.files.contains_key("b.txt") && !only1.files.contains_key("c.txt"));

    assert!(!repo.snapshot("status").unwrap().changed);

    assert!(repo.split(&p2, &["nope.txt".into()]).is_err());

    let _ = h2;

}

| **Status** | Draft 0.6l |

Rewriting a change `C` to `C'` (amend, rebase, split, squash) produces a new object with the same ChangeId. Amending an older change with the working copy's edits (`oxy amend --into C`) is allowed when every atom, placement, and node those edits reference exists in `C`'s closure; the edits are appended to `C` with references to `C` turned into self references, so `C`'s own atoms keep their indices and dependents are rewritten with an identity correspondence. Splitting a head (`oxy split C PATH..`) rebuilds it as a first change holding its effect on the named paths and a second holding the rest under the original ChangeId. Any change `D` with `hash(C) ∈ deps(D)` is orphaned relative to `C'`. `oxy` MUST automatically rewrite orphaned descendants by translating their AtomRefs and PlacementRefs from `C` to `C'` where a correspondence exists, and MUST record a conflict (§9) where it does not. Until the shape of that conflict is specified, an implementation MAY instead refuse the rewrite, naming the orphaned reference. Removing `C` altogether rewires each dependent to depend on `deps(C)`, and is refused where a dependent references `C`'s atoms or placements. Changes that do not depend on `C` are untouched, and a rewritten change by another author is stored without that author's signature, which only they can renew. Rewriting is recorded in the operation log (§12) and is undoable.

*Changelog.* Draft 0.6l (2026-09-27): amend into older changes and split (§8.4).

Draft 0.6k (2026-09-27): hook execution model and JSON payloads (§20).

    /// Fold the working copy into the head it sits on, or into CHANGE with --into

        /// Amend an older change; the edits must touch only lines it already knows

        #[arg(long)]

        into: Option<String>,

    /// Split a head: the named paths become a separate first change

    Split {

        change: String,

        paths: Vec<String>,

    },

        Cmd::Amend { message, into } => workspace::amend(message.as_deref(), into.as_deref()),

        Cmd::Split { change, paths } => workspace::split(&change, &paths),

pub fn amend(message: Option<&str>, into: Option<&str>) -> Result<i32> {

    let new = match into {

        Some(spec) => {

            let target = repo.resolve_change(spec)?;

            repo.amend_into(&target, message)?

        }

        None => repo.amend(message)?,

    };

pub fn split(change: &str, paths: &[String]) -> Result<i32> {

    let repo = open()?;

    let h = repo.resolve_change(change)?;

    let (h1, h2) = repo.split(&h, paths)?;

    let c1 = repo.store().get_change(&h1)?;

    let c2 = repo.store().get_change(&h2)?;

    println!("{} into {} {} and {} {}", ui::ok("Split"), ui::id(short_id(&c1)), ui::hash(format!("#{}", h1.short(12))), ui::id(short_id(&c2)), ui::hash(format!("#{}", h2.short(12))));

    Ok(0)

}