Answer a clean status from the manifest alone da868d5d2646

    /// Whether the file was executable: a mode change alters neither size

    /// nor time.

    pub exec: bool,

/// or `-`, graph key or `-`, `x` when executable or `-`, path.

    exec: bool,

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

        graph.unwrap_or("-"),

        if exec { "x" } else { "-" }

                e.exec,

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

                match (f.len() == 7).then(|| keys.get(f[6])).flatten() {

                        "{}\t{}\t{}\t{}\t{k}\t{}\t{}\n",

                        f[0], f[1], f[2], f[3], f[5], f[6]

            // A line of another shape (an older manifest) is no entry: the

            // file is then read, and the next snapshot rewrites the line.

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

            if f.len() == 7 {

                    f[6].to_string(),

                        exec: f[5] == "x",

    /// Whether the working copy is certainly clean, known from the manifest

    /// alone, without loading any history (spec §12.4): the last snapshot

    /// or commit found no uncommitted work and no conflict, every entry is

    /// older than the racy window (so an equal size and time mean equal

    /// content), there are no subrepos (whose state the manifest does not

    /// hold), and no file was added, removed or changed since. `false`

    /// means only that a snapshot must decide.

    pub fn clean_by_manifest(&self) -> Result<bool> {

        let _t = crate::timing::phase("status: check the manifest");

        let Some((conflicted, uncommitted, m)) = self.read_manifest()? else {

            return Ok(false);

        };

        if conflicted || uncommitted || self.root.join(".oxymodules").exists() {

            return Ok(false);

        }

        let racy = m

            .entries

            .values()

            .any(|e| e.mtime_ns + 2_000_000_000 >= m.written_ns);

        if racy {

            return Ok(false);

        }

        Ok(self.quick_dirty()? == Some(false))

    }

            if m.len() != me.size || super::is_executable(&m) != me.exec {

                || super::is_executable(&m) != me.exec

| Lazy text and keys at commit | 3.7 s | 768 MB |

| And answered from the manifest | 0.72 s | 120 MB |

| Git | 0.22 s | 31 MB |

A clean status is now answered from the manifest alone, loading no

history. The manifest also records the executable bit, since a mode

change alters neither size nor time. Any change, a manifest older than

the racy window, or subrepos send it back to a full snapshot.

Still to do: status to the 0.4 s target (the walk and reading the

manifest); a status without a usable manifest still builds every graph

and is killed at 14 GB; `fsck` is killed at

The reference implementation's cache is the workspace **manifest** written after every snapshot, commit, and checkout: per file its size, mtime, executable bit, 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.

A commit records in the manifest the graph key of every text file of its new base (except files with an `eol` attribute, whose bytes on disk are not the rendering), from a history-only load that builds no graph, so the first snapshot after it reads and renders no unchanged file. A history-only load reads no stored insert's text blob (§7.4) until it builds that file's graph. `oxy status` answers from the manifest alone, loading no history, when the manifest records no uncommitted work and no conflict, every entry is older than the racy window, the repository has no subrepos, and every file matches its entry (size, mtime or content, executable bit) with none added or removed; anything else takes a snapshot.

*Changelog.* Draft 0.8r (2026-09-29): graph keys at commit, lazy text in history-only loads, and a clean `status` from the manifest (§12.4); a parent checkout never moves a subrepo's bookmark backwards, and the pin is read from the nested working copy (§7.8); `bookmark create --upto/--only` (§10.1); the working-copy lock covers every command that writes the working copy; a workspace changed by two concurrent operations is an error (§12.1). Draft 0.8q (2026-09-29): change format version 2 stores large inserts as text blobs, so a change does not grow with the files it adds (§6.1, §7.4); no object may exceed 1 GiB (§13.2). Draft 0.8p (2026-09-29): Git import derives new NodeIds from the commit, making imports deterministic (§23). Draft 0.8o (2026-09-29): execution receipts, the `receipt` object and attestation (§14.6). Draft 0.8n (2026-09-29): line history, `oxy log -L` (§27). Draft 0.8m (2026-09-29): resolving replace conflicts (§9.3). Draft 0.8l (2026-09-28): deleting a reference on a remote; first serials from the clock (§16.4). 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).

    // Clean by the manifest alone: no history to load (oxygen#35).

    if !json && repo.clean_by_manifest()? {

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

        let heads = repo.bookmark_heads()?;

        println!(

            "{} {}{}working copy {}{}{}",

            ui::dim("On"),

            ui::bookmark(&repo.config.bookmark),

            ui::sep(),

            ui::id(wc.change_id.short(8)),

            ui::sep(),

            ui::dim(plural(heads.len(), "head"))

        );

        println!(

            "  {} {}",

            ui::ok(ui::glyph("✔", "*")),

            ui::dim("nothing to commit, working copy clean")

        );

        return Ok(0);

    }

/// oxygen#35: a clean status is answered from the manifest, loading no

/// history; any change, a mode change included, falls back to a snapshot.

#[test]

fn a_clean_status_needs_no_history_and_misses_no_change() {

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

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

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let r = tmp.path().join("repo");

    assert_eq!(oxy(tmp.path(), &home, &["init", r.to_str().unwrap()]).0, 0);

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

    for f in ["a.txt", "b.txt"] {

        write(&r, f, &format!("{f}\n"));

        std::fs::File::options()

            .write(true)

            .open(r.join(f))

            .unwrap()

            .set_modified(old)

            .unwrap();

    }

    assert_eq!(oxy(&r, &home, &["commit", "-m", "two"]).0, 0);

    let status = |r: &Path| {

        let out = Command::new(env!("CARGO_BIN_EXE_oxy"))

            .args(["--plain", "status"])

            .current_dir(r)

            .env("OXY_HOME", &home)

            .env("NO_COLOR", "1")

            .env("OXY_TIMINGS", "1")

            .output()

            .unwrap();

        (

            String::from_utf8_lossy(&out.stdout).to_string(),

            String::from_utf8_lossy(&out.stderr).to_string(),

        )

    };

    let (out, err) = status(&r);

    assert!(out.contains("working copy clean"), "{out}");

    assert!(!err.contains("snapshot"), "no snapshot was needed: {err}");

    // A mode change alters neither size nor time.

    std::fs::set_permissions(r.join("a.txt"), std::fs::Permissions::from_mode(0o755)).unwrap();

    let (out, err) = status(&r);

    assert!(out.contains("a.txt"), "{out}");

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

    std::fs::set_permissions(r.join("a.txt"), std::fs::Permissions::from_mode(0o644)).unwrap();

    // A new file.

    write(&r, "c.txt", "c\n");

    let (out, _) = status(&r);

    assert!(out.contains("c.txt"), "{out}");

}