History editing: orphaned references on rewrite are reified by re-anchoring (nearest surviving line of the chain, else the chain's anchors; vanished nodes drop their edits) and reported as notes instead of refused (spec 0.6m) 6706bdcfb63e

--- crates/oxy-core/src/repo/history.rs
-//! are rewritten through `crate::rewrite`, with their references translated.
-        let rewritten = propagate(&state, *old, new, corr, &load).map_err(|e| RepoError::Msg(format!("{e}; rewriting through such references is not implemented yet")))?;
-        Ok(new_hash)
-    /// Drop a change from the bookmark. Dependents that merely depend on it
-    /// inherit its dependencies; one that references its atoms or placements
-    /// cannot be rewritten yet. A dropped head's content stays on disk as
-    /// uncommitted work if the working copy sat on it.
-    pub fn abandon(&self, hash: &ChangeHash) -> Result<()> {
-            self.rewrite_change(hash, None, &Correspondence::default(), &format!("oxy abandon {}", c.change_id.short(8)))?;
-        Ok(())
+//! are rewritten through `crate::rewrite`, with their references translated
+//! and orphaned references reified as re-anchoring, reported as notes.
+        self.rewrite_change_noted(old, new, corr, command).map(|(h, _)| h)
+    }
+
+    /// Like `rewrite_change`, also returning notes about reified references.
+    fn rewrite_change_noted(&self, old: &ChangeHash, new: Option<&Change>, corr: &Correspondence, command: &str) -> Result<(Option<ChangeHash>, Vec<String>)> {
+        let propagation = propagate(&state, *old, new, corr, &load).map_err(|e| RepoError::Msg(e.to_string()))?;
+        let rewritten = propagation.changes;
+        Ok((new_hash, propagation.notes))
+    /// Drop a change from the bookmark. Dependents inherit its dependencies;
+    /// references into it are reified by re-anchoring (spec §8.4) and the
+    /// adjustments are returned as notes. A dropped head's content stays on
+    /// disk as uncommitted work if the working copy sat on it.
+    pub fn abandon(&self, hash: &ChangeHash) -> Result<Vec<String>> {
+            Ok(vec![])
+            let (_, notes) = self.rewrite_change_noted(hash, None, &Correspondence::default(), &format!("oxy abandon {}", c.change_id.short(8)))?;
+            Ok(notes)
--- crates/oxy-core/src/repo/tests.rs
-    // Abandoning a non-head whose dependent references its atoms is refused;
-    // one that is only an explicit dependency can go.
-    assert!(repo.abandon(&h1_now).unwrap_err().to_string().contains("not implemented"));
+    // Abandoning a non-head whose dependent references its atoms reifies
+    // the references (here: a.txt vanishes with it, so the dependent's edit
+    // of a.txt is dropped with a note) instead of refusing; undo restores it.
+    let notes = repo.abandon(&h1_now).unwrap();
+    assert!(!notes.is_empty(), "the dependent's edit of a.txt was reified");
+    let heads = repo.bookmark_heads().unwrap();
+    let after = repo.load_state(&heads).unwrap().materialize();
+    assert!(!after.files.contains_key("a.txt") && after.files.contains_key("b.txt"), "{:?}", after.files.keys());
+    repo.undo().unwrap();
+    assert_eq!(repo.bookmark_heads().unwrap(), vec![base]);
--- crates/oxy-core/src/rewrite.rs
-//! to `new`'s. Rewritten changes keep their ChangeIds. Where a reference has
-//! no counterpart, the rewrite fails with the orphaned reference named;
-//! turning that into a reified conflict is future work.
-    #[error("change {change} references {what} of the rewritten change, which no longer exists")]
-    Orphaned { change: ChangeHash, what: String },
-/// Returns `(old hash, rewritten change)` pairs in dependency order, not
-/// including `old` → `new` itself.
-pub fn propagate(state: &State, old: ChangeHash, new: Option<&Change>, corr: &Correspondence, load: &dyn Fn(&ChangeHash) -> Option<Change>) -> Result<Vec<(ChangeHash, Change)>, RewriteError> {
-    let old_change = state.get(&old).ok_or(RewriteError::Missing(old))?;
-        None => Replacement::Removed(old_change.deps.clone()),
-        let rewritten = rewrite_one(&h, &c, &mapping, &corrs)?;
-    Ok(out)
-fn rewrite_one(hash: &ChangeHash, c: &Change, mapping: &HashMap<ChangeHash, Replacement>, corrs: &HashMap<ChangeHash, Correspondence>) -> Result<Change, RewriteError> {
-    let orphan = |what: String| RewriteError::Orphaned { change: *hash, what };
-    let target = |change: &ChangeHash, what: &str| -> Result<Option<ChangeHash>, RewriteError> {
-        match mapping.get(change) {
-            Some(Replacement::Change(nh)) => Ok(Some(*nh)),
-            Some(Replacement::Removed(_)) => Err(orphan(what.to_string())),
-            None => Ok(None),
-    };
-    let map_atom = |r: AtomRef| -> Result<AtomRef, RewriteError> {
-            AtomRef::Atom { change, index } => match target(&change, &format!("atom {index}"))? {
-                Some(nh) => {
-                    let idx = corrs[&change].atoms.get(&index).ok_or_else(|| orphan(format!("atom {index}")))?;
-                    Ok(AtomRef::Atom { change: nh, index: *idx })
-                None => Ok(r),
-            other => Ok(other),
-    let map_op = |r: OpRef| -> Result<OpRef, RewriteError> {
-        match target(&r.change, &format!("tree operation {}", r.index))? {
-            Some(nh) => {
-                let idx = corrs[&r.change].ops.get(&r.index).ok_or_else(|| orphan(format!("tree operation {}", r.index)))?;
-                Ok(OpRef { change: nh, index: *idx })
-            }
-            None => Ok(r),
-    for op in &mut out.tree_ops {
-            TreeOp::RemoveNode { placement, .. } => *placement = map_op(*placement)?,
-            TreeOp::Move { old, .. } => *old = map_op(*old)?,
-            TreeOp::SetMode { old, .. } => *old = map_op(*old)?,
-            TreeOp::AddNode { .. } => {}
-    for e in &mut out.edits {
-            Edit::Insert { after, before, .. } => {
-                *after = map_atom(*after)?;
-                *before = map_atom(*before)?;
-            }
-            Edit::Delete { atoms, .. } => {
-                        match map_atom(AtomRef::Atom { change: r.change, index: i })? {
-                            AtomRef::Atom { change, index } => mapped.push((change, index)),
-                            _ => unreachable!(),
-                *atoms = ranges;
-            Edit::Replace { .. } => {}
-    Ok(out)
-        let rewritten = propagate(&st, h1, Some(&n1), &Correspondence::identity(&c1), &load).unwrap();
-    fn missing_counterpart_is_reported() {
-        // The rewritten c1 drops line "b": atom 1 has no counterpart.
-        let err = propagate(&st, h1, Some(&n1), &corr, &load).unwrap_err();
-        assert_eq!(err, RewriteError::Orphaned { change: h2, what: "atom 1".into() });
-        let out = propagate(&st, h2, None, &Correspondence::default(), &load).unwrap();
-        let out = propagate(&st, h1, None, &Correspondence::default(), &load).unwrap();
-        // Removing c2 when c3 references its placement fails.
-        let err = propagate(&st, h2, None, &Correspondence::default(), &load2).unwrap_err();
-        assert!(matches!(err, RewriteError::Orphaned { change, .. } if change == h4 || change == h3), "{err:?}");
+//! to `new`'s. Rewritten changes keep their ChangeIds.
+//!
+//! Where a reference has no counterpart it is reified rather than refused:
+//! an insert anchor moves to the nearest surviving atom of the same insert
+//! chain in `old`, else to that chain's own anchors (an order conflict then
+//! arises naturally if `new` placed other content there); deletions of
+//! vanished atoms are dropped; operations and edits on nodes that vanished
+//! are dropped. Every such adjustment is reported as a note.
+/// The result of propagating a rewrite.
+#[derive(Clone, Debug, Default)]
+pub struct Propagation {
+    /// `(old hash, rewritten change)` in dependency order.
+    pub changes: Vec<(ChangeHash, Change)>,
+    /// Human-readable descriptions of reified orphaned references.
+    pub notes: Vec<String>,
+}
+
+/// Where each atom of a change was inserted: the chain it belongs to.
+struct Chain {
+    first: u32,
+    last: u32,
+    after: AtomRef,
+    before: AtomRef,
+}
+
+fn chains_of(c: &Change) -> Vec<Chain> {
+    let mut per_node: HashMap<crate::ids::NodeId, u32> = HashMap::new();
+    let mut out = Vec::new();
+    for e in &c.edits {
+        if let Edit::Insert { node, after, before, lines } = e {
+            let idx = per_node.entry(*node).or_default();
+            out.push(Chain { first: *idx, last: *idx + lines.len() as u32 - 1, after: *after, before: *before });
+            *idx += lines.len() as u32;
+        }
+    }
+    out
+}
+
+/// The result lists `(old hash, rewritten change)` pairs in dependency
+/// order, not including `old` → `new` itself, plus notes about reified
+/// orphaned references.
+pub fn propagate(state: &State, old: ChangeHash, new: Option<&Change>, corr: &Correspondence, load: &dyn Fn(&ChangeHash) -> Option<Change>) -> Result<Propagation, RewriteError> {
+    let old_meta = state.get(&old).ok_or(RewriteError::Missing(old))?;
+    let old_full = load(&old);
+        None => Replacement::Removed(old_meta.deps.clone()),
+    // Chains of the rewritten change, for re-anchoring; vanished nodes.
+    let chains: HashMap<ChangeHash, Vec<Chain>> = old_full.as_ref().map(|c| (old, chains_of(c))).into_iter().collect();
+    let mut vanished_nodes: BTreeSet<crate::ids::NodeId> = BTreeSet::new();
+    if let Some(c) = &old_full {
+        for (i, op) in c.tree_ops.iter().enumerate() {
+            if let TreeOp::AddNode { node, .. } = op {
+                let survives = new.is_some() && corr.ops.contains_key(&(i as u32));
+                if !survives {
+                    vanished_nodes.insert(*node);
+                }
+            }
+        }
+    }
+    let mut notes = Vec::new();
+        let rewritten = rewrite_one(&h, &c, &mapping, &corrs, &chains, &vanished_nodes, &mut notes);
+    Ok(Propagation { changes: out, notes })
+/// Re-anchor a reference to a vanished atom of `change`: the nearest
+/// surviving atom of its chain (before it for `after` anchors, after it for
+/// `before` anchors), else the chain's own anchor.
+fn reanchor(change: &ChangeHash, index: u32, want_after: bool, mapping: &HashMap<ChangeHash, Replacement>, corrs: &HashMap<ChangeHash, Correspondence>, chains: &HashMap<ChangeHash, Vec<Chain>>) -> AtomRef {
+    let corr = corrs.get(change);
+    let chain = chains.get(change).and_then(|cs| cs.iter().find(|ch| ch.first <= index && index <= ch.last));
+    if let (Some(Replacement::Change(nh)), Some(corr), Some(ch)) = (mapping.get(change), corr, chain) {
+        let candidates: Box<dyn Iterator<Item = u32>> = if want_after { Box::new((ch.first..index).rev()) } else { Box::new(index + 1..=ch.last) };
+        for j in candidates {
+            if let Some(nj) = corr.atoms.get(&j) {
+                return AtomRef::Atom { change: *nh, index: *nj };
+            }
+    }
+    match chain {
+        Some(ch) => if want_after { ch.after } else { ch.before },
+        None => if want_after { AtomRef::Start } else { AtomRef::End },
+    }
+}
+
+fn rewrite_one(
+    hash: &ChangeHash,
+    c: &Change,
+    mapping: &HashMap<ChangeHash, Replacement>,
+    corrs: &HashMap<ChangeHash, Correspondence>,
+    chains: &HashMap<ChangeHash, Vec<Chain>>,
+    vanished_nodes: &BTreeSet<crate::ids::NodeId>,
+    notes: &mut Vec<String>,
+) -> Change {
+    let short = hash.short(12);
+    // An anchor: translate, or re-anchor when its counterpart is gone.
+    let map_anchor = |r: AtomRef, want_after: bool, notes: &mut Vec<String>| -> AtomRef {
+            AtomRef::Atom { change, index } => match mapping.get(&change) {
+                Some(Replacement::Change(nh)) => match corrs[&change].atoms.get(&index) {
+                    Some(idx) => AtomRef::Atom { change: *nh, index: *idx },
+                    None => {
+                        notes.push(format!("change {short}: an anchor line of the rewritten change vanished; re-anchored to its nearest neighbour"));
+                        reanchor(&change, index, want_after, mapping, corrs, chains)
+                    }
+                },
+                Some(Replacement::Removed(_)) => {
+                    notes.push(format!("change {short}: an anchor line of the removed change vanished; re-anchored to its neighbours"));
+                    reanchor(&change, index, want_after, mapping, corrs, chains)
+                None => r,
+            other => other,
+    // A tree-operation reference: translate, or `None` when gone.
+    let map_op = |r: OpRef| -> Option<OpRef> {
+        match mapping.get(&r.change) {
+            Some(Replacement::Change(nh)) => corrs[&r.change].ops.get(&r.index).map(|idx| OpRef { change: *nh, index: *idx }),
+            Some(Replacement::Removed(_)) => None,
+            None => Some(r),
+    let mut ops = Vec::new();
+    for op in &out.tree_ops {
+        let node = op.node();
+        if vanished_nodes.contains(&node) || matches!(op, TreeOp::AddNode { parent, .. } if vanished_nodes.contains(parent)) {
+            notes.push(format!("change {short}: an operation on a file that vanished with the rewritten change was dropped"));
+            continue;
+        }
+            TreeOp::RemoveNode { node, placement } => match map_op(*placement) {
+                Some(p) => ops.push(TreeOp::RemoveNode { node: *node, placement: p }),
+                None => notes.push(format!("change {short}: removal of a placement that vanished was dropped")),
+            },
+            TreeOp::Move { node, old, parent, name } => match map_op(*old) {
+                Some(o) => ops.push(TreeOp::Move { node: *node, old: o, parent: *parent, name: name.clone() }),
+                None => notes.push(format!("change {short}: a move of {name} lost its origin and was dropped")),
+            },
+            TreeOp::SetMode { node, old, mode } => match map_op(*old) {
+                Some(o) => ops.push(TreeOp::SetMode { node: *node, old: o, mode: *mode }),
+                None => notes.push(format!("change {short}: a mode change lost its origin and was dropped")),
+            },
+            add @ TreeOp::AddNode { .. } => ops.push(add.clone()),
+    out.tree_ops = ops;
+    let mut edits = Vec::new();
+    for e in &out.edits {
+        if vanished_nodes.contains(&e.node()) {
+            notes.push(format!("change {short}: an edit of a file that vanished with the rewritten change was dropped"));
+            continue;
+        }
+            Edit::Insert { node, after, before, lines } => edits.push(Edit::Insert {
+                node: *node,
+                after: map_anchor(*after, true, notes),
+                before: map_anchor(*before, false, notes),
+                lines: lines.clone(),
+            }),
+            Edit::Delete { node, atoms } => {
+                let mut dropped = 0;
+                        match mapping.get(&r.change) {
+                            Some(Replacement::Change(nh)) => match corrs[&r.change].atoms.get(&i) {
+                                Some(idx) => mapped.push((*nh, *idx)),
+                                None => dropped += 1,
+                            },
+                            Some(Replacement::Removed(_)) => dropped += 1,
+                            None => mapped.push((r.change, i)),
+                if dropped > 0 {
+                    notes.push(format!("change {short}: {dropped} deletion(s) of lines that vanished were dropped"));
+                }
+                if !ranges.is_empty() {
+                    edits.push(Edit::Delete { node: *node, atoms: ranges });
+                }
+            other => edits.push(other.clone()),
+    out.edits = edits;
+    out
+        let rewritten = propagate(&st, h1, Some(&n1), &Correspondence::identity(&c1), &load).unwrap().changes;
+    fn missing_counterpart_is_reanchored() {
+        // The rewritten c1 drops line "b": atom 1 has no counterpart, so c2's
+        // insert after "b" is re-anchored after "a", the nearest survivor.
+        let p = propagate(&st, h1, Some(&n1), &corr, &load).unwrap();
+        assert_eq!(p.notes.len(), 1, "{:?}", p.notes);
+        let n1h = n1.hash();
+        assert!(matches!(p.changes[0].1.edits[0], Edit::Insert { after: AtomRef::Atom { change, index: 0 }, before: AtomRef::End, .. } if change == n1h));
+        let mut st2 = State::new();
+        st2.add(n1.clone()).unwrap();
+        st2.add(p.changes[0].1.clone()).unwrap();
+        let m = st2.materialize();
+        assert!(!m.is_conflicted());
+        assert!(matches!(&m.files["f"].content, FileContent::Text { bytes, .. } if bytes == b"a\nc\n"));
+
+        // Removing c1 altogether: f vanishes with it, so c2's edit is dropped.
+        let p = propagate(&st, h1, None, &Correspondence::default(), &load).unwrap();
+        assert_eq!(p.notes.len(), 1, "{:?}", p.notes);
+        assert!(p.changes[0].1.edits.is_empty() && p.changes[0].1.deps.is_empty());
+
+        // Rewriting c1 to keep the file but none of its lines: c2's line goes
+        // to c1's chain anchors (START, END).
+        let mut n2 = c1.clone();
+        n2.edits = vec![];
+        let corr = Correspondence { atoms: HashMap::new(), ops: [(0, 0)].into_iter().collect() };
+        let p = propagate(&st, h1, Some(&n2), &corr, &load).unwrap();
+        assert!(matches!(p.changes[0].1.edits[0], Edit::Insert { after: AtomRef::Start, before: AtomRef::End, .. }));
+        let mut st3 = State::new();
+        st3.add(n2.clone()).unwrap();
+        st3.add(p.changes[0].1.clone()).unwrap();
+        let m = st3.materialize();
+        assert!(!m.is_conflicted());
+        assert!(matches!(&m.files["f"].content, FileContent::Text { bytes, .. } if bytes == b"c\n"));
+        let out = propagate(&st, h2, None, &Correspondence::default(), &load).unwrap().changes;
+        let out = propagate(&st, h1, None, &Correspondence::default(), &load).unwrap().changes;
+        // Removing c2, which created g: c3's edit of g and c4's removal of g's
+        // placement are dropped with notes, since the file no longer exists.
+        let p = propagate(&st, h2, None, &Correspondence::default(), &load2).unwrap();
+        assert_eq!(p.notes.len(), 2, "{:?}", p.notes);
+        for (_, c) in &p.changes {
+            assert!(c.edits.is_empty() && c.tree_ops.is_empty());
+        }
--- docs/spec.md
-| **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).
+| **Status** | Draft 0.6m |
+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. Where none exists the reference is **reified by re-anchoring**: an insert anchored on a vanished atom is anchored instead on the nearest surviving atom of the same insert chain of `C` (the preceding one for `after`, the following one for `before`), or on that chain's own anchors when none survives, so that an order conflict (§9.1) arises exactly when `C'` placed other content there; a deletion of a vanished atom is dropped; an operation or edit on a node that vanished with `C` is dropped. Each adjustment MUST be reported to the user. Removing `C` altogether rewires each dependent to depend on `deps(C)` and reifies references into `C` the same way. 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.6m (2026-09-27): orphaned references on rewrite are reified by re-anchoring rather than refused (§8.4).
+
+Draft 0.6l (2026-09-27): amend into older changes and split (§8.4).
--- src/cli/workspace.rs
-    repo.abandon(&h)?;
+    let notes = repo.abandon(&h)?;
+    for n in notes {
+        println!("  {} {n}", ui::warn("note:"));
+    }

Author

Andy McCall @andymccall <[email protected]>

When

1 month ago · 2026-09-26 23:34 UTC

Signature

✔ signed by Andy McCall

Hash

6706bdcfb63ea62675f92c26046956565ff87b2019fcd17a1e93031be7746d85

Depends on

135212de5370 23b217d75848 252e8cb23fbc 614541c3cebd 982864068a59 c07e0e7d2d85 fce44ae9ad29 ff0af1ee299d

Depended on by

2c9ddac3c387 631fc8970bd0 98a1620a3840 75167672ebcd 728da0f92161 94084087a876 28fc23d7706a

In bookmarks

agents-in-readme bare-hashes carried-not-removed carry-identical doctor-trust identical-sides keyless-tags main merge-remote-bookmark only-help-103 paths-for-resolutions-and-amend push-notes show-stat subrepo-pin-state switch-says

In tags

v0.1.0 v0.10.0 v0.11.0 v0.2.0 v0.3.0 v0.3.1 v0.4.0 v0.4.1 v0.4.2 v0.4.3 v0.4.4 v0.4.5 v0.4.6 v0.5.0 v0.5.1 v0.6.0 v0.7.0 v0.8.0 v0.9.0

Edits

53 atoms, 0 tree operations, 5 files

Browse the tree at this change

//! History editing (spec §8.4): describe, amend, abandon.

//!

//! `describe` and `abandon` work on any change of the bookmark: dependents

//! are rewritten through `crate::rewrite`, with their references translated.

//! are rewritten through `crate::rewrite`, with their references translated

//! and orphaned references reified as re-anchoring, reported as notes.

//! `amend` works on heads, where the amended change is rebuilt from the files

//! on disk. A rewritten change keeps its ChangeId and gets a new hash; old

//! objects stay in the store until garbage collection. Rewritten changes by

70 unchanged lines

    /// rewriting every dependent, including the working copy. Returns the

    /// new hash of `old`, if any.

    fn rewrite_change(&self, old: &ChangeHash, new: Option<&Change>, corr: &Correspondence, command: &str) -> Result<Option<ChangeHash>> {

        self.rewrite_change_noted(old, new, corr, command).map(|(h, _)| h)

    }

    /// Like `rewrite_change`, also returning notes about reified references.

    fn rewrite_change_noted(&self, old: &ChangeHash, new: Option<&Change>, corr: &Correspondence, command: &str) -> Result<(Option<ChangeHash>, Vec<String>)> {

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

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

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

9 unchanged lines

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

        }

        let load = |h: &ChangeHash| self.store.get_change(h).ok();

        let rewritten = propagate(&state, *old, new, corr, &load).map_err(|e| RepoError::Msg(format!("{e}; rewriting through such references is not implemented yet")))?;

        let propagation = propagate(&state, *old, new, corr, &load).map_err(|e| RepoError::Msg(e.to_string()))?;

        let rewritten = propagation.changes;

        let mut mapping: HashMap<ChangeHash, ChangeHash> = HashMap::new();

        let new_hash = match new {

29 unchanged lines

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

        self.record_op(&[op_ref], command, view)?;

        self.drop_manifest();

        Ok(new_hash)

        Ok((new_hash, propagation.notes))

    }

    /// Change the message of any change of the bookmark; dependents are rewritten.

57 unchanged lines

        Ok(self.replace_head(&head, Some(&new), &format!("oxy amend {}", old.change_id.short(8)))?.unwrap())

    }

    /// Drop a change from the bookmark. Dependents that merely depend on it

    /// inherit its dependencies; one that references its atoms or placements

    /// cannot be rewritten yet. A dropped head's content stays on disk as

    /// uncommitted work if the working copy sat on it.

    pub fn abandon(&self, hash: &ChangeHash) -> Result<()> {

    /// Drop a change from the bookmark. Dependents inherit its dependencies;

    /// references into it are reified by re-anchoring (spec §8.4) and the

    /// adjustments are returned as notes. A dropped head's content stays on

    /// disk as uncommitted work if the working copy sat on it.

    pub fn abandon(&self, hash: &ChangeHash) -> Result<Vec<String>> {

        let c = self.store.get_change(hash)?;

        if c.kind == ChangeKind::WorkingCopy {

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

1 unchanged lines

        let heads = self.bookmark_heads()?;

        if heads.contains(hash) {

            self.replace_head(hash, None, &format!("oxy abandon {}", c.change_id.short(8)))?;

            Ok(vec![])

        } else {

            self.rewrite_change(hash, None, &Correspondence::default(), &format!("oxy abandon {}", c.change_id.short(8)))?;

            let (_, notes) = self.rewrite_change_noted(hash, None, &Correspondence::default(), &format!("oxy abandon {}", c.change_id.short(8)))?;

            Ok(notes)

        }

        Ok(())

    }

}

263 unchanged lines

881 unchanged lines

    repo.undo().unwrap();

    assert_eq!(repo.bookmark_heads().unwrap(), vec![h2d]);

    // Abandoning a non-head whose dependent references its atoms is refused;

    // one that is only an explicit dependency can go.

    // Abandoning a non-head whose dependent references its atoms reifies

    // the references (here: a.txt vanishes with it, so the dependent's edit

    // of a.txt is dropped with a note) instead of refusing; undo restores it.

    let base = repo.bookmark_heads().unwrap()[0];

    let base_change = repo.store().get_change(&base).unwrap();

    let h1_now = base_change.deps[0];

    assert!(repo.abandon(&h1_now).unwrap_err().to_string().contains("not implemented"));

    let notes = repo.abandon(&h1_now).unwrap();

    assert!(!notes.is_empty(), "the dependent's edit of a.txt was reified");

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

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

    assert!(!after.files.contains_key("a.txt") && after.files.contains_key("b.txt"), "{:?}", after.files.keys());

    repo.undo().unwrap();

    assert_eq!(repo.bookmark_heads().unwrap(), vec![base]);

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

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

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

698 unchanged lines

//! Rewrite propagation (spec §8.4): when change `old` is replaced by `new`,

//! every change that depends on `old` is rewritten with its references

//! translated through a correspondence from `old`'s atoms and tree operations

//! to `new`'s. Rewritten changes keep their ChangeIds. Where a reference has

//! no counterpart, the rewrite fails with the orphaned reference named;

//! turning that into a reified conflict is future work.

//! to `new`'s. Rewritten changes keep their ChangeIds.

//!

//! Where a reference has no counterpart it is reified rather than refused:

//! an insert anchor moves to the nearest surviving atom of the same insert

//! chain in `old`, else to that chain's own anchors (an order conflict then

//! arises naturally if `new` placed other content there); deletions of

//! vanished atoms are dropped; operations and edits on nodes that vanished

//! are dropped. Every such adjustment is reported as a note.

use crate::hash::ChangeHash;

use crate::objects::{AtomRange, AtomRef, Change, Edit, OpRef, TreeOp};

37 unchanged lines

#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]

pub enum RewriteError {

    #[error("change {change} references {what} of the rewritten change, which no longer exists")]

    Orphaned { change: ChangeHash, what: String },

    #[error("change {0} is not in the state")]

    Missing(ChangeHash),

}

/// The result of propagating a rewrite.

#[derive(Clone, Debug, Default)]

pub struct Propagation {

    /// `(old hash, rewritten change)` in dependency order.

    pub changes: Vec<(ChangeHash, Change)>,

    /// Human-readable descriptions of reified orphaned references.

    pub notes: Vec<String>,

}

/// Where each atom of a change was inserted: the chain it belongs to.

struct Chain {

    first: u32,

    last: u32,

    after: AtomRef,

    before: AtomRef,

}

fn chains_of(c: &Change) -> Vec<Chain> {

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

    let mut out = Vec::new();

    for e in &c.edits {

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

            let idx = per_node.entry(*node).or_default();

            out.push(Chain { first: *idx, last: *idx + lines.len() as u32 - 1, after: *after, before: *before });

            *idx += lines.len() as u32;

        }

    }

    out

}

/// What a rewritten change was replaced by.

#[derive(Clone, Debug)]

enum Replacement {

4 unchanged lines

/// Rewrite every change in `state` that depends on `old`, given `new` (or

/// `None` when `old` is removed) and the correspondence between them.

/// Returns `(old hash, rewritten change)` pairs in dependency order, not

/// including `old` → `new` itself.

/// The result lists `(old hash, rewritten change)` pairs in dependency

/// order, not including `old` → `new` itself, plus notes about reified

/// orphaned references.

///

/// `load` fetches a change's full object (a state keeps only metadata).

pub fn propagate(state: &State, old: ChangeHash, new: Option<&Change>, corr: &Correspondence, load: &dyn Fn(&ChangeHash) -> Option<Change>) -> Result<Vec<(ChangeHash, Change)>, RewriteError> {

    let old_change = state.get(&old).ok_or(RewriteError::Missing(old))?;

pub fn propagate(state: &State, old: ChangeHash, new: Option<&Change>, corr: &Correspondence, load: &dyn Fn(&ChangeHash) -> Option<Change>) -> Result<Propagation, RewriteError> {

    let old_meta = state.get(&old).ok_or(RewriteError::Missing(old))?;

    let old_full = load(&old);

    let mut mapping: HashMap<ChangeHash, Replacement> = HashMap::new();

    mapping.insert(old, match new {

        Some(n) => Replacement::Change(n.hash()),

        None => Replacement::Removed(old_change.deps.clone()),

        None => Replacement::Removed(old_meta.deps.clone()),

    });

    let mut corrs: HashMap<ChangeHash, Correspondence> = HashMap::new();

    corrs.insert(old, corr.clone());

    // Chains of the rewritten change, for re-anchoring; vanished nodes.

    let chains: HashMap<ChangeHash, Vec<Chain>> = old_full.as_ref().map(|c| (old, chains_of(c))).into_iter().collect();

    let mut vanished_nodes: BTreeSet<crate::ids::NodeId> = BTreeSet::new();

    if let Some(c) = &old_full {

        for (i, op) in c.tree_ops.iter().enumerate() {

            if let TreeOp::AddNode { node, .. } = op {

                let survives = new.is_some() && corr.ops.contains_key(&(i as u32));

                if !survives {

                    vanished_nodes.insert(*node);

                }

            }

        }

    }

    let mut notes = Vec::new();

    // Dependents in topological order: every change whose closure has `old`,

    // sorted so that dependencies come first.

3 unchanged lines

    let mut out = Vec::new();

    for h in dependents {

        let c = load(&h).ok_or(RewriteError::Missing(h))?;

        let rewritten = rewrite_one(&h, &c, &mapping, &corrs)?;

        let rewritten = rewrite_one(&h, &c, &mapping, &corrs, &chains, &vanished_nodes, &mut notes);

        let rh = rewritten.hash();

        corrs.insert(h, Correspondence::identity(&rewritten));

        mapping.insert(h, Replacement::Change(rh));

        out.push((h, rewritten));

    }

    Ok(out)

    Ok(Propagation { changes: out, notes })

}

fn rewrite_one(hash: &ChangeHash, c: &Change, mapping: &HashMap<ChangeHash, Replacement>, corrs: &HashMap<ChangeHash, Correspondence>) -> Result<Change, RewriteError> {

    let orphan = |what: String| RewriteError::Orphaned { change: *hash, what };

    let target = |change: &ChangeHash, what: &str| -> Result<Option<ChangeHash>, RewriteError> {

        match mapping.get(change) {

            Some(Replacement::Change(nh)) => Ok(Some(*nh)),

            Some(Replacement::Removed(_)) => Err(orphan(what.to_string())),

            None => Ok(None),

/// Re-anchor a reference to a vanished atom of `change`: the nearest

/// surviving atom of its chain (before it for `after` anchors, after it for

/// `before` anchors), else the chain's own anchor.

fn reanchor(change: &ChangeHash, index: u32, want_after: bool, mapping: &HashMap<ChangeHash, Replacement>, corrs: &HashMap<ChangeHash, Correspondence>, chains: &HashMap<ChangeHash, Vec<Chain>>) -> AtomRef {

    let corr = corrs.get(change);

    let chain = chains.get(change).and_then(|cs| cs.iter().find(|ch| ch.first <= index && index <= ch.last));

    if let (Some(Replacement::Change(nh)), Some(corr), Some(ch)) = (mapping.get(change), corr, chain) {

        let candidates: Box<dyn Iterator<Item = u32>> = if want_after { Box::new((ch.first..index).rev()) } else { Box::new(index + 1..=ch.last) };

        for j in candidates {

            if let Some(nj) = corr.atoms.get(&j) {

                return AtomRef::Atom { change: *nh, index: *nj };

            }

        }

    };

    let map_atom = |r: AtomRef| -> Result<AtomRef, RewriteError> {

    }

    match chain {

        Some(ch) => if want_after { ch.after } else { ch.before },

        None => if want_after { AtomRef::Start } else { AtomRef::End },

    }

}

fn rewrite_one(

    hash: &ChangeHash,

    c: &Change,

    mapping: &HashMap<ChangeHash, Replacement>,

    corrs: &HashMap<ChangeHash, Correspondence>,

    chains: &HashMap<ChangeHash, Vec<Chain>>,

    vanished_nodes: &BTreeSet<crate::ids::NodeId>,

    notes: &mut Vec<String>,

) -> Change {

    let short = hash.short(12);

    // An anchor: translate, or re-anchor when its counterpart is gone.

    let map_anchor = |r: AtomRef, want_after: bool, notes: &mut Vec<String>| -> AtomRef {

        match r {

            AtomRef::Atom { change, index } => match target(&change, &format!("atom {index}"))? {

                Some(nh) => {

                    let idx = corrs[&change].atoms.get(&index).ok_or_else(|| orphan(format!("atom {index}")))?;

                    Ok(AtomRef::Atom { change: nh, index: *idx })

            AtomRef::Atom { change, index } => match mapping.get(&change) {

                Some(Replacement::Change(nh)) => match corrs[&change].atoms.get(&index) {

                    Some(idx) => AtomRef::Atom { change: *nh, index: *idx },

                    None => {

                        notes.push(format!("change {short}: an anchor line of the rewritten change vanished; re-anchored to its nearest neighbour"));

                        reanchor(&change, index, want_after, mapping, corrs, chains)

                    }

                },

                Some(Replacement::Removed(_)) => {

                    notes.push(format!("change {short}: an anchor line of the removed change vanished; re-anchored to its neighbours"));

                    reanchor(&change, index, want_after, mapping, corrs, chains)

                }

                None => Ok(r),

                None => r,

            },

            other => Ok(other),

            other => other,

        }

    };

    let map_op = |r: OpRef| -> Result<OpRef, RewriteError> {

        match target(&r.change, &format!("tree operation {}", r.index))? {

            Some(nh) => {

                let idx = corrs[&r.change].ops.get(&r.index).ok_or_else(|| orphan(format!("tree operation {}", r.index)))?;

                Ok(OpRef { change: nh, index: *idx })

            }

            None => Ok(r),

    // A tree-operation reference: translate, or `None` when gone.

    let map_op = |r: OpRef| -> Option<OpRef> {

        match mapping.get(&r.change) {

            Some(Replacement::Change(nh)) => corrs[&r.change].ops.get(&r.index).map(|idx| OpRef { change: *nh, index: *idx }),

            Some(Replacement::Removed(_)) => None,

            None => Some(r),

        }

    };

    let mut out = c.clone();

10 unchanged lines

        }

    }

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

    for op in &mut out.tree_ops {

    let mut ops = Vec::new();

    for op in &out.tree_ops {

        let node = op.node();

        if vanished_nodes.contains(&node) || matches!(op, TreeOp::AddNode { parent, .. } if vanished_nodes.contains(parent)) {

            notes.push(format!("change {short}: an operation on a file that vanished with the rewritten change was dropped"));

            continue;

        }

        match op {

            TreeOp::RemoveNode { placement, .. } => *placement = map_op(*placement)?,

            TreeOp::Move { old, .. } => *old = map_op(*old)?,

            TreeOp::SetMode { old, .. } => *old = map_op(*old)?,

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

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

                Some(p) => ops.push(TreeOp::RemoveNode { node: *node, placement: p }),

                None => notes.push(format!("change {short}: removal of a placement that vanished was dropped")),

            },

            TreeOp::Move { node, old, parent, name } => match map_op(*old) {

                Some(o) => ops.push(TreeOp::Move { node: *node, old: o, parent: *parent, name: name.clone() }),

                None => notes.push(format!("change {short}: a move of {name} lost its origin and was dropped")),

            },

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

                Some(o) => ops.push(TreeOp::SetMode { node: *node, old: o, mode: *mode }),

                None => notes.push(format!("change {short}: a mode change lost its origin and was dropped")),

            },

            add @ TreeOp::AddNode { .. } => ops.push(add.clone()),

        }

    }

    for e in &mut out.edits {

    out.tree_ops = ops;

    let mut edits = Vec::new();

    for e in &out.edits {

        if vanished_nodes.contains(&e.node()) {

            notes.push(format!("change {short}: an edit of a file that vanished with the rewritten change was dropped"));

            continue;

        }

        match e {

            Edit::Insert { after, before, .. } => {

                *after = map_atom(*after)?;

                *before = map_atom(*before)?;

            }

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

            Edit::Insert { node, after, before, lines } => edits.push(Edit::Insert {

                node: *node,

                after: map_anchor(*after, true, notes),

                before: map_anchor(*before, false, notes),

                lines: lines.clone(),

            }),

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

                let mut mapped: Vec<(ChangeHash, u32)> = Vec::new();

                let mut dropped = 0;

                for r in atoms.iter() {

                    for i in r.from..r.to {

                        match map_atom(AtomRef::Atom { change: r.change, index: i })? {

                            AtomRef::Atom { change, index } => mapped.push((change, index)),

                            _ => unreachable!(),

                        match mapping.get(&r.change) {

                            Some(Replacement::Change(nh)) => match corrs[&r.change].atoms.get(&i) {

                                Some(idx) => mapped.push((*nh, *idx)),

                                None => dropped += 1,

                            },

                            Some(Replacement::Removed(_)) => dropped += 1,

                            None => mapped.push((r.change, i)),

                        }

                    }

                }

                if dropped > 0 {

                    notes.push(format!("change {short}: {dropped} deletion(s) of lines that vanished were dropped"));

                }

                let mut ranges: Vec<AtomRange> = Vec::new();

                for (ch, i) in mapped {

                    match ranges.last_mut() {

1 unchanged lines

                        _ => ranges.push(AtomRange { change: ch, from: i, to: i + 1 }),

                    }

                }

                *atoms = ranges;

                if !ranges.is_empty() {

                    edits.push(Edit::Delete { node: *node, atoms: ranges });

                }

            }

            Edit::Replace { .. } => {}

            other => edits.push(other.clone()),

        }

    }

    out.edits = edits;

    out.normalize();

    Ok(out)

    out

}

#[cfg(test)]

27 unchanged lines

        n1.message = "one, described".into();

        let all: HashMap<ChangeHash, Change> = [(h1, c1.clone()), (h2, c2.clone()), (h3, c3.clone())].into_iter().collect();

        let load = |h: &ChangeHash| all.get(h).cloned();

        let rewritten = propagate(&st, h1, Some(&n1), &Correspondence::identity(&c1), &load).unwrap();

        let rewritten = propagate(&st, h1, Some(&n1), &Correspondence::identity(&c1), &load).unwrap().changes;

        assert_eq!(rewritten.iter().map(|(h, _)| *h).collect::<Vec<_>>(), vec![h2, h3]);

        let mut st2 = State::new();

        st2.add(n1.clone()).unwrap();

16 unchanged lines

    }

    #[test]

    fn missing_counterpart_is_reported() {

    fn missing_counterpart_is_reanchored() {

        let mut st = State::new();

        let f = NodeId::random();

        let c1 = change(vec![], vec![TreeOp::AddNode { node: f, kind: NodeKind::File, mode: Mode::TEXT, parent: NodeId::ROOT, name: "f".into() }], vec![Edit::Insert { node: f, after: AtomRef::Start, before: AtomRef::End, lines: vec![b"a\n".to_vec(), b"b\n".to_vec()] }], "one");

2 unchanged lines

        let h2 = st.add(c2.clone()).unwrap();

        let all: HashMap<ChangeHash, Change> = [(h1, c1.clone()), (h2, c2)].into_iter().collect();

        let load = |h: &ChangeHash| all.get(h).cloned();

        // The rewritten c1 drops line "b": atom 1 has no counterpart.

        // The rewritten c1 drops line "b": atom 1 has no counterpart, so c2's

        // insert after "b" is re-anchored after "a", the nearest survivor.

        let mut n1 = c1.clone();

        n1.edits = vec![Edit::Insert { node: f, after: AtomRef::Start, before: AtomRef::End, lines: vec![b"a\n".to_vec()] }];

        let corr = Correspondence { atoms: [(0, 0)].into_iter().collect(), ops: [(0, 0)].into_iter().collect() };

        let err = propagate(&st, h1, Some(&n1), &corr, &load).unwrap_err();

        assert_eq!(err, RewriteError::Orphaned { change: h2, what: "atom 1".into() });

        let p = propagate(&st, h1, Some(&n1), &corr, &load).unwrap();

        assert_eq!(p.notes.len(), 1, "{:?}", p.notes);

        let n1h = n1.hash();

        assert!(matches!(p.changes[0].1.edits[0], Edit::Insert { after: AtomRef::Atom { change, index: 0 }, before: AtomRef::End, .. } if change == n1h));

        let mut st2 = State::new();

        st2.add(n1.clone()).unwrap();

        st2.add(p.changes[0].1.clone()).unwrap();

        let m = st2.materialize();

        assert!(!m.is_conflicted());

        assert!(matches!(&m.files["f"].content, FileContent::Text { bytes, .. } if bytes == b"a\nc\n"));

        assert_eq!(propagate(&st, ObjectRef([9; 32]), Some(&n1), &corr, &load).unwrap_err(), RewriteError::Missing(ObjectRef([9; 32])));

        // Removing c1 altogether: f vanishes with it, so c2's edit is dropped.

        let p = propagate(&st, h1, None, &Correspondence::default(), &load).unwrap();

        assert_eq!(p.notes.len(), 1, "{:?}", p.notes);

        assert!(p.changes[0].1.edits.is_empty() && p.changes[0].1.deps.is_empty());

        // Rewriting c1 to keep the file but none of its lines: c2's line goes

        // to c1's chain anchors (START, END).

        let mut n2 = c1.clone();

        n2.edits = vec![];

        let corr = Correspondence { atoms: HashMap::new(), ops: [(0, 0)].into_iter().collect() };

        let p = propagate(&st, h1, Some(&n2), &corr, &load).unwrap();

        assert!(matches!(p.changes[0].1.edits[0], Edit::Insert { after: AtomRef::Start, before: AtomRef::End, .. }));

        let mut st3 = State::new();

        st3.add(n2.clone()).unwrap();

        st3.add(p.changes[0].1.clone()).unwrap();

        let m = st3.materialize();

        assert!(!m.is_conflicted());

        assert!(matches!(&m.files["f"].content, FileContent::Text { bytes, .. } if bytes == b"c\n"));

    }

    #[test]

12 unchanged lines

        let load_all = all.clone();

        let load = move |h: &ChangeHash| load_all.get(h).cloned();

        // Removing c2 (an explicit-only dependency of nothing that references it) works: c3 inherits h1.

        let out = propagate(&st, h2, None, &Correspondence::default(), &load).unwrap();

        let out = propagate(&st, h2, None, &Correspondence::default(), &load).unwrap().changes;

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

        assert_eq!(out[0].0, h3);

        assert_eq!(out[0].1.deps, vec![h1]);

        // Removing c1 fails: c2 does not reference c1 (only an explicit dep), but

        // nothing else does either, so it succeeds and c2 inherits no deps.

        let out = propagate(&st, h1, None, &Correspondence::default(), &load).unwrap();

        let out = propagate(&st, h1, None, &Correspondence::default(), &load).unwrap().changes;

        assert!(out.iter().any(|(h, c)| *h == h2 && c.deps.is_empty()));

        // Removing c2 when c3 references its placement fails.

        // Removing c2, which created g: c3's edit of g and c4's removal of g's

        // placement are dropped with notes, since the file no longer exists.

        let c4 = change(vec![h2], vec![TreeOp::RemoveNode { node: g, placement: OpRef { change: h2, index: 0 } }], vec![], "four");

        let h4 = st.add(c4.clone()).unwrap();

        all.insert(h4, c4);

        let load2 = |h: &ChangeHash| all.get(h).cloned();

        let err = propagate(&st, h2, None, &Correspondence::default(), &load2).unwrap_err();

        assert!(matches!(err, RewriteError::Orphaned { change, .. } if change == h4 || change == h3), "{err:?}");

        let p = propagate(&st, h2, None, &Correspondence::default(), &load2).unwrap();

        assert_eq!(p.notes.len(), 2, "{:?}", p.notes);

        for (_, c) in &p.changes {

            assert!(c.edits.is_empty() && c.tree_ops.is_empty());

        }

    }

}

1 unchanged lines

| | |

|---|---|

| **Status** | Draft 0.6l |

| **Status** | Draft 0.6m |

| **Format version** | 1 |

| **Date** | 2026-09-26 |

| **Audience** | Implementers, security reviewers, and contributors |

308 unchanged lines

### 8.4 Rewriting

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.

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. Where none exists the reference is **reified by re-anchoring**: an insert anchored on a vanished atom is anchored instead on the nearest surviving atom of the same insert chain of `C` (the preceding one for `after`, the following one for `before`), or on that chain's own anchors when none survives, so that an order conflict (§9.1) arises exactly when `C'` placed other content there; a deletion of a vanished atom is dropped; an operation or edit on a node that vanished with `C` is dropped. Each adjustment MUST be reported to the user. Removing `C` altogether rewires each dependent to depend on `deps(C)` and reifies references into `C` the same way. 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.

## 9. Conflicts

518 unchanged lines

---

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

*Changelog.* Draft 0.6m (2026-09-27): orphaned references on rewrite are reified by re-anchoring rather than refused (§8.4).

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).

37 unchanged lines

264 unchanged lines

    let repo = open()?;

    let h = repo.resolve_change(change)?;

    let c = repo.store().get_change(&h)?;

    repo.abandon(&h)?;

    let notes = repo.abandon(&h)?;

    println!("Abandoned {} #{}; its content remains on disk as uncommitted work if the working copy sat on it.", short_id(&c), h.short(12));

    for n in notes {

        println!("  {} {n}", ui::warn("note:"));

    }

    Ok(0)

}

154 unchanged lines