Status snapshots skip files unchanged since the manifest cc7a00565161

                    ..FsEntry::new(*kind, f.mode.exec, vec![])

use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};

    /// A text file known equal to the base's rendering without reading it:

    /// its stat matches the manifest and the manifest recorded it equal to

    /// a base file graph with the same key (spec §12.3). `content` is empty.

    pub unchanged: bool,

    /// The base graph key this file equals, for the next manifest.

    pub graph_key: Option<String>,

            unchanged: false,

            graph_key: None,

            self.read_blobs(refs).map_err(|e| {

                crate::objects::ObjectError::Schema(format!("checkpoint graph blobs: {e}"))

            })

        })?)

    }

    /// Build every graph a history-only state still lacks, making it full.

    pub fn load_all_graphs(&self, state: &mut State) -> Result<()> {

        Ok(state.load_all_graphs(|refs| {

    /// match it is not read: an opaque file yields its known blob, and a

    /// text file whose recorded graph key equals its base graph's key in

    /// `keys` (path → key) is marked unchanged; other text files are read

    /// but keep their known hash. Files modified within two seconds of the

    /// manifest are never trusted (a racy stat).

    ///

    /// `.oxyattributes` files are always read, since their content is

    /// needed; and when any of them is not known unchanged (added, removed,

    /// edited, or changed in the base), no text file is taken as unchanged,

    /// because attributes decide how a file compares with the base.

        keys: Option<&HashMap<String, String>>,

        let keys = keys.filter(|k| {

            let on_disk: HashSet<&str> = files.iter().map(|(r, _, _)| r.as_str()).collect();

            let attrs_unchanged =

                files

                    .iter()

                    .filter(|(r, _, _)| is_attributes(r))

                    .all(|(rel, _, meta)| {

                        stat_cached(rel, meta, cache)

                            .is_some_and(|e| e.graph.is_some() && e.graph.as_ref() == k.get(rel))

                    });

            let none_removed = tracked

                .keys()

                .filter(|r| is_attributes(r))

                .all(|r| on_disk.contains(r.as_str()));

            attrs_unchanged && none_removed

        });

                    let key = keys

                        .filter(|_| !is_attributes(rel))

                        .and_then(|k| k.get(rel))

                        .map(String::as_str);

                    Ok((rel.clone(), read_file_entry(rel, path, meta, cache, key)?))

                            ..FsEntry::new(NodeKind::Subrepo, false, vec![])

}

/// Whether `rel` is an attributes file (spec §7.6).

fn is_attributes(rel: &str) -> bool {

    rel == ".oxyattributes" || rel.ends_with("/.oxyattributes")

/// The manifest entry for `rel` when its size and mtime match it outside

/// the racy window.

fn stat_cached<'m>(

    rel: &str,

    meta: &fs::Metadata,

    cache: Option<&'m prompt::Manifest>,

) -> Option<&'m prompt::ManifestEntry> {

    let m = cache?;

    let e = m.entries.get(rel)?;

    let mtime_ns = prompt::mtime_ns(meta);

    let racy = mtime_ns + 2_000_000_000 >= m.written_ns;

    (e.size == meta.len() && e.mtime_ns == mtime_ns && !racy).then_some(e)

}

/// Read one working-copy file, or serve it from the stat cache (spec

/// §12.3). With a manifest whose stat for it is unchanged (and not racy),

/// an opaque file is not read at all (its stored blob stands in), and a

/// text file the manifest recorded equal to a base graph whose key is

/// `key`, the key the base has now, is not read either: equal keys mean

/// equal renderings, so it still equals the base. Touches no repository

/// state, so the walk runs it in parallel; the caller checks that a cached

/// blob is still in the store.

    key: Option<&str>,

    Ok(match stat_cached(rel, meta, cache) {

            content_hash: Some(e.hash.clone()),

            ..FsEntry::new(NodeKind::File, exec, vec![])

        },

        Some(e) if key.is_some() && e.graph.as_deref() == key => FsEntry {

            content_hash: Some(e.hash.clone()),

            unchanged: true,

            graph_key: e.graph.clone(),

            ..FsEntry::new(NodeKind::File, exec, vec![])

        },

        Some(e) => FsEntry {

            ..FsEntry::new(NodeKind::File, exec, fs::read(path)?)

    /// The graph key (`State::graph_key`) of the base file this text file

    /// was found equal to, rendered, byte for byte.

    pub graph: Option<String>,

/// or `-`, graph key or `-`, path.

    graph: Option<&str>,

        "{size}\t{mtime_ns}\t{hash}\t{}\t{}\t{path}\n",

        blob.map(|b| b.to_hex()).unwrap_or_else(|| "-".into()),

        graph.unwrap_or("-")

            text.push_str(&manifest_line(

                path,

                size,

                mtime_ns,

                &hash,

                blob,

                e.graph_key.as_deref(),

            ));

            let f: Vec<&str> = line.splitn(6, '\t').collect();

            if f.len() == 6 {

                    f[5].to_string(),

                        graph: (f[4] != "-").then(|| f[4].to_string()),

    /// The result carries the full base state and its whole rendering.

        self.snapshot_as(command, false)

    }

    /// Snapshot the working copy as [`Repo::snapshot`] does, for commands

    /// that need only its statuses, conflicts and base history (status,

    /// log, show). Text files known unchanged since the last manifest are

    /// neither read nor rendered: the result's `base` is a history-only

    /// state without their graphs, and its `base_snapshot` lists them in

    /// `unrendered` with empty bytes. They are never conflicted.

    pub fn snapshot_status(&self, command: &str) -> Result<SnapshotResult> {

        self.snapshot_as(command, true)

    }

    fn snapshot_as(&self, command: &str, partial: bool) -> Result<SnapshotResult> {

        let result = self.snapshot_locked(command, partial);

    fn snapshot_locked(&self, command: &str, partial: bool) -> Result<SnapshotResult> {

        // The base's history first: its graph keys say which files the

        // manifest already knows equal to it.

        let mut base = {

            let _t = crate::timing::phase("snapshot: load base history");

            self.load_state_history(&old_wc.deps)?

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

        let keys: HashMap<String, String> = view

            .entries

            .iter()

            .filter(|(_, e)| e.kind == NodeKind::File && !e.mode.opaque)

            .filter_map(|(p, e)| {

                let k = base.graph_key(&e.node)?;

                Some((p.clone(), crate::hash::ObjectRef(k).to_hex()))

            })

            .collect();

        let manifest = self.read_manifest()?.map(|(_, _, m)| m);

        let tracked: BTreeMap<String, (NodeKind, Option<ObjectRef>)> = {

            let _t = crate::timing::phase("snapshot: tracked paths");

            let mut t = BTreeMap::new();

            for (p, e) in &view.entries {

                if e.kind == NodeKind::Dir {

                    continue;

                }

                let blob = if e.kind != NodeKind::File || e.mode.opaque {

                    base.live_blobs(&e.node).first().copied()

                } else {

                    None

                };

                t.insert(p.clone(), (e.kind, blob));

            }

            t

        };

        let mut fs_entries = {

            let _t = crate::timing::phase("snapshot: read working copy");

            self.walk_working_copy_with(manifest.as_ref(), &tracked, Some(&keys))?

        };

            let _t = crate::timing::phase("snapshot: load and render base");

            if partial {

                let skip: HashSet<NodeId> = fs_entries

                    .iter()

                    .filter(|(_, e)| e.unchanged)

                    .filter_map(|(p, _)| view.entries.get(p).map(|e| e.node))

                    .collect();

                let need: Vec<NodeId> = view

                    .entries

                    .values()

                    .filter(|e| e.kind == NodeKind::File && !skip.contains(&e.node))

                    .map(|e| e.node)

                    .collect();

                self.load_graphs_of(&mut base, &need)?;

                base.materialize_except(&skip)

            } else {

                self.load_all_graphs(&mut base)?;

                base.materialize()

            }

        // Text files found equal to an unconflicted base rendering keep its

        // graph key, so the next snapshot need not read or render them.

        {

            let changed: HashSet<&str> = built.statuses.iter().map(|s| s.path.as_str()).collect();

            for (p, e) in fs_entries.iter_mut() {

                if e.unchanged || e.kind != NodeKind::File || changed.contains(p.as_str()) {

                    continue;

                }

                e.graph_key = match base_snapshot.files.get(p).map(|f| &f.content) {

                    Some(FileContent::Text {

                        bytes,

                        materialized,

                    }) if !materialized.is_conflicted() && *bytes == e.content => {

                        keys.get(p).cloned()

                    }

                    _ => None,

                };

            }

        }

        if e.unchanged {

            // Known equal to the base's unconflicted rendering (spec

            // §12.3); only the executable bit can differ.

            if e.exec != expected.mode.exec {

                if let Some(old) = mode_atom {

                    self.tree_ops.push(TreeOp::SetMode {

                        node,

                        old,

                        mode: Mode {

                            exec: e.exec,

                            opaque: false,

                        },

                    });

                    self.statuses.push(PathStatus {

                        path: path.to_string(),

                        status: ChangeStatus::ModeChanged,

                    });

                }

            }

            return Ok(());

        }

/// Status snapshots (spec §12.3): a text file whose stat matches the

/// manifest, and whose base graph key is the one the manifest recorded it

/// equal to, is neither read nor rendered; any edit, and any change to the

/// file's graph in the base, brings it back.

#[cfg(unix)]

#[test]

fn status_snapshots_skip_files_unchanged_since_the_manifest() {

    use std::os::unix::fs::PermissionsExt;

    hermetic();

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

    let root = dir.path();

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

    for (p, c) in [("a.txt", "one\n"), ("b.txt", "bee\n"), ("d/c.txt", "sea\n")] {

        write(root, p, c.as_bytes());

    }

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

    let age = |p: &str| {

        let old = std::time::SystemTime::now() - std::time::Duration::from_secs(30);

        fs::File::options()

            .write(true)

            .open(root.join(p))

            .unwrap()

            .set_modified(old)

            .unwrap();

    };

    let lock = |p: &str, mode: u32| {

        fs::set_permissions(root.join(p), fs::Permissions::from_mode(mode)).unwrap()

    };

    for p in ["a.txt", "b.txt", "d/c.txt"] {

        age(p);

    }

    assert!(repo.snapshot("status").unwrap().statuses.is_empty());

    let (_, _, m) = repo.read_manifest().unwrap().unwrap();

    assert!(

        m.entries.values().all(|e| e.graph.is_some()),

        "keys recorded"

    );

    // Unreadable files prove they are not read; the status snapshot does

    // not render them either, and its base lacks their graphs.

    lock("a.txt", 0o000);

    lock("b.txt", 0o000);

    let snap = repo.snapshot_status("status").unwrap();

    assert!(!snap.changed && snap.statuses.is_empty());

    assert_eq!(

        snap.base_snapshot

            .unrendered

            .iter()

            .cloned()

            .collect::<Vec<_>>(),

        vec!["a.txt", "b.txt", "d/c.txt"]

    );

    assert!(!snap.base.is_full());

    assert!(!snap.base_snapshot.is_conflicted());

    // A full snapshot does not read them either, but renders everything.

    let full = repo.snapshot("status").unwrap();

    assert!(full.statuses.is_empty() && full.base.is_full());

    assert!(full.base_snapshot.unrendered.is_empty());

    assert!(matches!(&full.base_snapshot.files["a.txt"].content,

        FileContent::Text { bytes, .. } if bytes == b"one\n"));

    // An edit is seen; the file is rendered, the others still are not.

    write(root, "d/c.txt", b"sea edited\n");

    let snap = repo.snapshot_status("status").unwrap();

    assert_eq!(

        statuses(&snap),

        vec![("d/c.txt".to_string(), ChangeStatus::Modified)]

    );

    assert!(!snap.base_snapshot.unrendered.contains("d/c.txt"));

    // So is a mode change of an unread file.

    lock("b.txt", 0o100);

    assert_eq!(

        statuses(&repo.snapshot_status("status").unwrap()),

        vec![

            ("b.txt".to_string(), ChangeStatus::ModeChanged),

            ("d/c.txt".to_string(), ChangeStatus::Modified)

        ]

    );

    lock("b.txt", 0o000);

    // Committing c.txt changes its graph in the base, not a.txt's: a.txt

    // stays unread, c.txt is read once and then skipped too.

    repo.commit_selection("edit c", &[], &Selection::Paths(vec!["d/c.txt".into()]))

        .unwrap();

    age("d/c.txt");

    let snap = repo.snapshot_status("status").unwrap();

    assert!(snap.statuses.is_empty(), "{:?}", snap.statuses);

    assert!(snap.base_snapshot.unrendered.contains("a.txt"));

    lock("d/c.txt", 0o000);

    let snap = repo.snapshot_status("status").unwrap();

    assert!(snap.statuses.is_empty());

    assert!(snap.base_snapshot.unrendered.contains("d/c.txt"));

    for p in ["a.txt", "b.txt", "d/c.txt"] {

        lock(p, 0o644);

    }

}

/// Attributes decide how a file compares with the base, so a changed

/// `.oxyattributes` makes every text file be compared again.

#[cfg(unix)]

#[test]

fn a_changed_attributes_file_disables_skipping_unchanged_files() {

    hermetic();

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

    let root = dir.path();

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

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

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

    let old = std::time::SystemTime::now() - std::time::Duration::from_secs(30);

    fs::File::options()

        .write(true)

        .open(root.join("a.txt"))

        .unwrap()

        .set_modified(old)

        .unwrap();

    assert!(repo.snapshot_status("status").unwrap().statuses.is_empty());

    assert!(repo

        .snapshot_status("status")

        .unwrap()

        .base_snapshot

        .unrendered

        .contains("a.txt"));

    // With eol=lf, a.txt as stored no longer equals the base.

    write(root, ".oxyattributes", b"*.txt eol=lf\n");

    let snap = repo.snapshot_status("status").unwrap();

    assert_eq!(

        statuses(&snap),

        vec![

            (".oxyattributes".to_string(), ChangeStatus::Added),

            ("a.txt".to_string(), ChangeStatus::Modified)

        ]

    );

}

    /// Text files left unrendered by [`State::materialize_except`]: their

    /// `bytes` are empty and they are known not to be conflicted.

    pub unrendered: BTreeSet<String>,

        // Pair each graph with its blob, then build them all in parallel:

        // graphs are independent.

        let mut work: Vec<(NodeId, Deferred, Option<Vec<u8>>)> = Vec::with_capacity(taken.len());

        for (node, d) in taken.drain(..) {

            let bytes = match &d.base {

                Some(DeferredBase::Blob(_)) => Some(

                    blobs

                        .ok_or_else(|| ObjectError::Schema("graph blobs: wrong count".into()))?,

                ),

                _ => None,

            work.push((node, d, bytes));

        use rayon::prelude::*;

        let built: Vec<(NodeId, FileGraph)> = work

            .into_par_iter()

            .map(|(node, mut d, bytes)| {

                let mut graph = match (d.base.take(), bytes) {

                    (Some(DeferredBase::Inline(v)), _) => FileGraph::from_value(&v)?,

                    (Some(DeferredBase::Blob(_)), Some(bytes)) => {

                        FileGraph::from_value(&cbor::decode(&bytes)?)?

                    }

                    _ => FileGraph::default(),

                };

                for (h, edits) in std::mem::take(&mut d.edits) {

                    apply_file_edits(&mut graph, h, edits);

                }

                Ok((node, graph))

            })

            .collect::<Result<_, ObjectError>>()?;

        self.files.extend(built);

        Ok(())

    }

    /// Build every graph a history-only state has not built, making it full.

    pub fn load_all_graphs(

        &mut self,

        load: impl FnOnce(&[ObjectRef]) -> Result<Vec<Vec<u8>>, ObjectError>,

    ) -> Result<(), ObjectError> {

        let nodes: Vec<NodeId> = match &self.deferred {

            Some(d) => d.keys().copied().collect(),

            None => return Ok(()),

        };

        self.load_graphs(&nodes, load)?;

        self.deferred = None;

    }

    /// A key for the graph of `node` in a history-only state that has not

    /// built it: equal keys mean equal graphs, so equal renderings (a

    /// rendering depends only on the graph and on the changes' own

    /// immutable metadata). It names the node, its checkpoint base (a blob,

    /// an inline value, or none) and the set of later changes that edited

    /// the file.

    /// `None` for a full state or a graph already built.

    pub fn graph_key(&self, node: &NodeId) -> Option<[u8; 32]> {

        let deferred = self.deferred.as_ref()?;

        if self.files.contains_key(node) {

            return None;

        }

        let mut h = blake3::Hasher::new();

        h.update(b"oxy graph key 1\0");

        // A change's edits are applied per node: the node is part of it.

        h.update(&node.0);

        let Some(d) = deferred.get(node) else {

            // Never edited: the empty graph.

            h.update(&[0]);

            return Some(*h.finalize().as_bytes());

        };

        match &d.base {

            None => h.update(&[0]),

            Some(DeferredBase::Blob(r)) => h.update(&[1]).update(&r.0),

            Some(DeferredBase::Inline(v)) => h.update(&[2]).update(&cbor::encode(v)),

        };

        let mut changes: Vec<&ChangeHash> = d.edits.iter().map(|(c, _)| c).collect();

        changes.sort();

        changes.dedup();

        h.update(&(changes.len() as u64).to_le_bytes());

        for c in changes {

            h.update(&c.0);

        }

        Some(*h.finalize().as_bytes())

        Snapshot {

            tree,

            files,

            unrendered: BTreeSet::new(),

        }

    }

    /// Like [`State::materialize`], leaving the text files of nodes in

    /// `skip` unrendered (listed in [`Snapshot::unrendered`]); every other

    /// file's graph must be loaded. For a caller that already knows those

    /// files are unchanged and not conflicted.

    pub fn materialize_except(&self, skip: &HashSet<NodeId>) -> Snapshot {

        use rayon::prelude::*;

        let tree = self.tree.view();

        let entries: Vec<(&String, &crate::tree::TreeEntry)> = tree.entries.iter().collect();

        let rendered: Vec<(String, FileState, bool)> = entries

            .par_iter()

            .map(|(path, e)| {

                if e.kind == NodeKind::File && !e.mode.opaque && skip.contains(&e.node) {

                    let f = FileState {

                        node: e.node,

                        kind: e.kind,

                        mode: e.mode,

                        content: FileContent::Text {

                            bytes: Vec::new(),

                            materialized: Materialized::default(),

                        },

                    };

                    (path.to_string(), f, true)

                } else {

                    (path.to_string(), self.file_state(e), false)

                }

            })

            .collect();

        let mut files = BTreeMap::new();

        let mut unrendered = BTreeSet::new();

        for (p, f, skipped) in rendered {

            if skipped {

                unrendered.insert(p.clone());

            }

            files.insert(p, f);

        }

        Snapshot {

            tree,

            files,

            unrendered,

        }

    #[test]

    fn graph_keys_change_exactly_when_a_graph_does() {

        let (f, g) = (NodeId::random(), NodeId::random());

        let add = |node: NodeId, name: &str| TreeOp::AddNode {

            node,

            kind: NodeKind::File,

            mode: Mode::TEXT,

            parent: NodeId::ROOT,

            name: name.into(),

        };

        let ins = |node: NodeId, line: &[u8]| Edit::Insert {

            node,

            after: AtomRef::Start,

            before: AtomRef::End,

            lines: vec![line.to_vec()],

        };

        let c1 = change(

            vec![],

            vec![add(f, "f"), add(g, "g")],

            vec![ins(f, b"f\n"), ins(g, b"g\n")],

        );

        let h1 = c1.hash();

        let c2 = change(vec![h1], vec![], vec![ins(g, b"g2\n")]);

        let h2 = c2.hash();

        let c3 = change(vec![h2], vec![], vec![ins(f, b"f2\n")]);

        let load = |cs: &[&Change]| {

            let mut st = State::new_history_only();

            for c in cs {

                st.add((*c).clone()).unwrap();

            }

            st

        };

        let s1 = load(&[&c1]);

        let s2 = load(&[&c1, &c2]);

        let s3 = load(&[&c1, &c2, &c3]);

        let key = |s: &State, n: &NodeId| s.graph_key(n).unwrap();

        assert_eq!(key(&s1, &f), key(&load(&[&c1]), &f), "same state, same key");

        assert_eq!(key(&s1, &f), key(&s2, &f), "an edit elsewhere keeps it");

        assert_ne!(key(&s1, &g), key(&s2, &g), "an edit of the file changes it");

        assert_ne!(key(&s2, &f), key(&s3, &f));

        assert_ne!(key(&s1, &f), key(&s1, &g), "different files differ");

        let mut built = load(&[&c1]);

        built.load_graphs(&[f], |_| unreachable!()).unwrap();

        assert!(built.graph_key(&f).is_none(), "a built graph has no key");

        let mut full = State::new();

        full.add(c1.clone()).unwrap();

        assert!(full.graph_key(&f).is_none(), "nor has a full state");

        // Through a version 2 checkpoint of c1, keys name its graph blobs

        // or inline values: stable across loads, changed by later edits.

        let graphs = full.checkpoint_file_graphs();

        let index = full.checkpoint_index(&graphs, |enc| {

            crate::hash::hash_object(crate::hash::ObjectType::Blob, enc)

        });

        let cp = |extra: &[&Change]| {

            let mut st = State::from_checkpoint_history(&index).unwrap();

            for c in extra {

                st.add((*c).clone()).unwrap();

            }

            st

        };

        assert_eq!(key(&cp(&[]), &f), key(&cp(&[]), &f));

        assert_eq!(key(&cp(&[]), &f), key(&cp(&[&c2]), &f));

        assert_ne!(key(&cp(&[]), &g), key(&cp(&[&c2]), &g));

        assert_ne!(key(&cp(&[&c2]), &f), key(&cp(&[&c2, &c3]), &f));

        // Partial rendering: skipped files are listed and empty, the others

        // render as in a full state.

        let mut part = load(&[&c1, &c2]);

        part.load_graphs(&[g], |_| unreachable!()).unwrap();

        let snap = part.materialize_except(&[f].into_iter().collect());

        assert_eq!(snap.unrendered, ["f".to_string()].into_iter().collect());

        let mut whole = State::new();

        whole.add(c1.clone()).unwrap();

        whole.add(c2.clone()).unwrap();

        assert_eq!(snap.files["g"], whole.materialize().files["g"]);

        assert!(

            matches!(&snap.files["f"].content, FileContent::Text { bytes, .. } if bytes.is_empty())

        );

    }

- [x] O10g Render only what a snapshot needs, first part: the manifest records, per file, the key of the base graph it matched, so an unchanged file whose graph is untouched is neither read nor rendered; used by status, log, show, tag and bookmark.

- [ ] O10h The same for commit, diff, amend and the other full snapshots: a lazy base that builds only the graphs the change touches; cache materialized states.

## 2026-09-28: O10g, first part: status snapshots skip unchanged files

The manifest now records, per text file equal to the base, the key of the

base graph it matched: the file's node, its checkpoint graph (blob,

inline value or none) and the set of later changes that edited it

(spec §12.4). When a file's stat and key both still match, the snapshot

neither reads nor renders it.

`status`, `log`, `show`, `tag` and `bookmark` use a partial snapshot. It

loads the base for its history and builds only the graphs of files that

are not known unchanged. `commit`, `diff` and the rest still build the

whole base.

10 000 files of 40 lines, 22 changes, a version 2 checkpoint after 21 of

them; `OXY_TIMINGS=1`, clean working copy:

| Operation | Before | After |

|---|---:|---:|

| status | 0.55 s | 0.22 s |

| status peak memory | 259 MB | 51 MB |

| log | 0.7–0.8 s | 0.38 s |

| diff (full snapshot) | 0.56 s | 0.57 s |

| Phase of a clean status snapshot | Before | After |

|---|---:|---:|

| load base (whole / history only) | 317 ms | 31 ms |

| render base | 91 ms | 25 ms |

| read working copy | 68 ms | 50 ms |

| diff against base | 41 ms | 28 ms |

| write manifest | 33 ms | 35 ms |

The same for `commit` and `diff` comes next (O10h). There, only the graphs

the change touches are needed, and materialized states can be cached.

| **Status** | Draft 0.8k |

The reference implementation's cache is the workspace **manifest** written after every snapshot, commit, and checkout: per file its size, mtime, content hash, and, for an opaque file, the ObjectRef of its stored blob. A text file found byte for byte equal to the base state's unconflicted rendering also records its **graph key**: a hash of the file's node, the checkpoint graph its graph was built from (a blob ref, an inline value, or none), and the set of later changes that edited it. Equal keys mean equal graphs and so equal renderings, since a rendering depends only on the graph and the changes' immutable metadata. On the next snapshot a file whose size and mtime match is not read: an opaque file contributes its recorded blob, and a text file whose recorded graph key equals the key of its base graph now is known equal to the base, so it is neither read nor rendered (a stat-clean file that differs from the base, such as an older uncommitted edit, is always read). Attributes decide how a file compares with the base, so `.oxyattributes` files are always read, and when any of them is added, removed, edited, or changed in the base, no text file is skipped. A file whose mtime lies within two seconds of the manifest's own write time is never trusted (the racy-stat window), so a modification that preserves size and lands in the same timestamp tick is still seen. An implementation MAY use a file-system monitor instead of, or in addition to, the manifest.

*Changelog.* Draft 0.8k (2026-09-28): the manifest records graph keys, so unchanged files are neither read nor rendered (§12.4). Draft 0.8j (2026-09-28): checkpoint payload version 2, file graphs by reference (§11).

        let conflicted = repo

            .snapshot_status("oxy pull")?

            .base_snapshot

            .is_conflicted();

    let snap = repo.snapshot_status("oxy status")?;

    let snap = repo.snapshot_status("oxy log")?;

    repo.snapshot_status("oxy show")?;

    let snap = repo.snapshot_status("oxy")?;

    repo.snapshot_status("oxy tag")?;

    repo.snapshot_status("oxy bookmark create")?;

    repo.snapshot_status("oxy bookmark set")?;