Spec review pass (Draft 0.7): oxy status --json, section 24 aligned with the CLI, reference implementation status table, capabilities and snapshot wording aligned with the implementation 50a046e439e9

    /// `oxy status --json` (spec §9.5): the changed paths and every conflict

    /// of the working copy's base with its kind, path, and contributing

    /// ChangeIds.

    pub fn status_json(&self, snap: &SnapshotResult) -> Result<String> {

        let heads = self.bookmark_heads()?;

        let base_snapshot = &snap.base_snapshot;

        let by_node = base_snapshot.tree.by_node();

        let path_of = |n: &NodeId| by_node.get(n).map(|e| e.path.clone());

        let id_of = |h: &ChangeHash| snap.base.get(h).map(|m| m.change_id.to_hex()).unwrap_or_else(|| h.to_hex());

        let paths = json_array(snap.statuses.iter().map(|s| format!("{{\"path\":{},\"status\":{}}}", json_str(&s.path), json_str(&format!("{:?}", s.status)))));

        let mut conflicts: Vec<String> = Vec::new();

        for (p, f) in &base_snapshot.files {

            if !f.is_conflicted() {

                continue;

            }

            let (kind, changes) = match &f.content {

                FileContent::Text { .. } => ("text", snap.base.conflict_regions(&f.node).contributors),

                FileContent::Opaque { blobs } => ("replace", snap.base.blob_contributors(&f.node, blobs)),

                FileContent::Dir => continue,

            };

            let resolved = match snap.statuses.iter().find(|s| s.path == *p).map(|s| s.status) {

                Some(ChangeStatus::Resolved) => "true",

                Some(ChangeStatus::ConflictEdited) => "\"markers\"",

                _ => "false",

            };

            conflicts.push(format!(

                "{{\"kind\":{},\"path\":{},\"node\":{},\"changes\":{},\"resolved\":{resolved}}}",

                json_str(kind),

                json_str(p),

                json_str(&f.node.to_hex()),

                json_array(changes.iter().map(|h| json_str(&id_of(h))))

            ));

        }

        for c in &base_snapshot.tree.conflicts {

            let (kind, nodes): (&str, Vec<NodeId>) = match c {

                crate::tree::TreeConflict::Name { nodes, .. } => ("name", nodes.clone()),

                crate::tree::TreeConflict::MultiPlacement { node, .. } => ("multi-placement", vec![*node]),

                crate::tree::TreeConflict::Orphan { node, .. } => ("orphan", vec![*node]),

                crate::tree::TreeConflict::Cycle { node } => ("cycle", vec![*node]),

                crate::tree::TreeConflict::Mode { node, .. } => ("mode", vec![*node]),

            };

            let detail = match c {

                crate::tree::TreeConflict::Name { name, parent, .. } => {

                    let dir = if *parent == NodeId::ROOT { String::new() } else { path_of(parent).unwrap_or_default() };

                    format!(",\"path\":{}", json_str(&if dir.is_empty() { name.clone() } else { format!("{dir}/{name}") }))

                }

                _ => nodes.first().and_then(path_of).map(|p| format!(",\"path\":{}", json_str(&p))).unwrap_or_default(),

            };

            conflicts.push(format!(

                "{{\"kind\":{},\"nodes\":{}{detail}}}",

                json_str(kind),

                json_array(nodes.iter().map(|n| json_str(&n.to_hex())))

            ));

        }

        Ok(format!(

            "{{\"bookmark\":{},\"working_copy\":{},\"heads\":{},\"clean\":{},\"conflicted\":{},\"paths\":{paths},\"conflicts\":{}}}",

            json_str(&self.config.bookmark),

            json_str(&snap.wc.change_id.to_hex()),

            heads.len(),

            snap.statuses.is_empty(),

            base_snapshot.is_conflicted(),

            json_array(conflicts)

        ))

    }

#[test]

fn status_json_lists_conflicts_with_contributors() {

    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"one\n");

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

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

    let ha = repo.commit("left", &[]).unwrap();

    repo.checkout(&[h1], true, "checkout").unwrap();

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

    let hb = repo.commit("right", &[]).unwrap();

    repo.checkout(&[ha, hb], true, "checkout").unwrap();

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

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

    let json = repo.status_json(&snap).unwrap();

    let ida = repo.store().get_change(&ha).unwrap().change_id.to_hex();

    let idb = repo.store().get_change(&hb).unwrap().change_id.to_hex();

    assert!(json.contains("\"conflicted\":true"), "{json}");

    assert!(json.contains("\"kind\":\"text\",\"path\":\"a.txt\""), "{json}");

    assert!(json.contains(&ida) && json.contains(&idb), "{json}");

    assert!(json.contains("\"resolved\":false"), "{json}");

    assert!(json.starts_with('{') && json.ends_with('}'));

    // Resolve and the report says so; a clean copy has no conflicts.

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

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

    let json = repo.status_json(&snap).unwrap();

    assert!(json.contains("\"resolved\":true"), "{json}");

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

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

    let json = repo.status_json(&snap).unwrap();

    assert!(json.contains("\"clean\":true,\"conflicted\":false,\"paths\":[],\"conflicts\":[]"), "{json}");

}

    /// The changes that introduced the live blobs of an opaque node, for a

    /// replace conflict (spec §9.3).

    pub fn blob_contributors(&self, node: &NodeId, blobs: &[ObjectRef]) -> Vec<ChangeHash> {

        let mut out: Vec<ChangeHash> = Vec::new();

        for (h, _, new) in self.replaces.get(node).map(|v| v.as_slice()).unwrap_or(&[]) {

            if new.is_some_and(|b| blobs.contains(&b)) && !out.contains(h) {

                out.push(*h);

            }

        }

        out.sort();

        out

    }

`status --json` prints the same for tools, with every conflict's kind, path and

contributing ChangeIds. On a terminal, `status` lists each path with a mark: `✚ added`, `✎ modified`, `✖ removed`,

- [x] Spec review pass: resolve or re-word every "MAY ... until" allowance introduced during implementation, and close what can be closed in §27. (Done as Draft 0.7: no "MAY ... until" wording remained; `oxy status --json` implemented to meet §9.5; §12.4, §16.1 and §24 aligned with the implementation; new §26.1 status table; §27 records workspace conflicts and server locks as open.)

- 2026-09-27 10:00 iteration 18: spec review pass (Draft 0.7) and oxy status --json. 113 tests.

| **Status** | Draft 0.7 |

`oxy status` MUST list every conflict, MUST exit with status 2 when any conflict exists in the working-copy state, MUST exit with status 3 when only workspace conflicts (§9.7) exist, and MUST support `--json` output enumerating conflicts by node, kind, and contributing ChangeIds. The JSON object has `bookmark`, `working_copy` (ChangeId), `heads`, `clean`, `conflicted`, `paths` (`[{path, status}]`) and `conflicts`: for a text or replace conflict `{kind, path, node, changes: [ChangeId], resolved: true | false | "markers"}`, for a tree conflict `{kind: name | multi-placement | orphan | cycle | mode, nodes, path?}`.

Implementations MUST support a stat-based crawl with a persistent cache keyed by at least `(path, size, mtime)` and SHOULD support a file-system monitor (Watchman or a native inotify/FSEvents/ReadDirectoryChangesW watcher) for the latency targets in §25.

| `GET capabilities` | — | `{ versions: [1], features }`; feature names are `seal`, and, when offered, `lock`; `max_frame` and `transports` are reserved for framed transports |

oxy init [PATH]                     oxy clone URL [--sparse PATH].. [--depth N] [--max-blob SIZE]

oxy status [--json]                 oxy diff                     oxy prompt [--format F]

oxy commit -m MSG [--depends-on CHANGE]..

oxy log [-n N] [-v]                 oxy show CHANGE

oxy describe [CHANGE] -m MSG        oxy amend [-m MSG] [--into CHANGE]

oxy split CHANGE [PATH]..           oxy abandon CHANGE           oxy resolve

oxy checkout [CHANGE].. [--discard] oxy undo                     oxy op log

oxy tag create NAME [CHANGE].. [-m MSG]   oxy tag list

oxy workspace add|list|forget       oxy sparse [PATH]..          oxy deepen [N]

oxy fetch [REMOTE]                  oxy pull [REMOTE]            oxy push [REMOTE] [--force]

oxy remote add|remove|list          oxy serve                    oxy lock|unlock PATH

oxy policy init|show|grant|revoke|root|sign                      oxy verify [CHANGE]

oxy checkpoint                      oxy gc [--now]               oxy config [--user] KEY VALUE

Change arguments accept a ChangeId prefix, a ChangeHash prefix (with `#`), a bookmark or tag name, and `@` for the working-copy change. Ambiguous prefixes are an error.

Reserved for a later version, with these names: `oxy new`, `oxy edit`, `oxy squash`, `oxy rebase` (commuting changes need no rebase; the command would re-express a change against different dependencies), `oxy redo`, revsets (`log -r`), `oxy bookmark create|set|delete|list` (one bookmark per workspace today), and `oxy remote trust` (with the Noise transport, §15).

### 26.1 Reference implementation status

The reference implementation (`crates/oxy-core`, `crates/oxy-server`, the `oxy` binary) as of this draft:

| Area | Status |

|---|---|

| Objects, hashing, deterministic CBOR (§5) | Implemented; format 2 repositories, migration from format 1 |

| Change graph, commutation, conflicts and resolution (§6–§9) | Implemented, including order, delete/insert, tree, replace, and mode conflicts; workspace conflicts (§9.7) and exit status 3 are not detected |

| Rewrites (§8.4) | Implemented: describe, amend (also into older changes), split, abandon; orphaned references re-anchored |

| Operation log, undo (§12.1) | Implemented; `redo` reserved |

| Snapshots and the stat cache (§12.3, §12.4) | Implemented; no file-system monitor yet |

| Storage: loose objects, packs, GC, checkpoints, batching (§11, §13, §21) | Implemented; pack indexes are read fully rather than mapped |

| Identity, composite signatures, seals, attestations, policy, lifecycle (§14) | Implemented; `lock` attestations reserved |

| HTTPS transport and endpoints (§16) | Implemented, HTTP only; Noise and ZCT (§15) reserved; negotiation is exact (no Merkle buckets); `refs` takes no `patterns` |

| Partial, sparse, shallow (§17) | Implemented |

| Locks (§18) | Local advisory locks only; server locks and the `lock` endpoint reserved |

| Configuration, attributes, hooks (§19, §20) | Implemented (`.oxyattributes`: binary, text, eol, nocompress, lockable) |

| Thin profile and proxy (§22) | Reserved |

| Git interoperability (§23) | Implemented: import, export, fetch, push, rename detection |

| Conformance suite (§26) | Partial: encoding, signature, permutation, conflict, rewrite, protocol, chunking and Git tests exist as unit and integration tests in the crates; a standalone vector suite is not published yet |

3. **Set reconciliation** at the scale of tens of millions of changes may need an IBLT-based negotiator; the Merkle bucket scheme in §16.2 is the v1 answer, and the reference implementation's exact negotiation is sufficient below that scale.

4. **Workspace conflicts (§9.7)** on case-insensitive file systems are specified but not yet detected by the reference implementation.

5. **Server-side locks (§18)** need the `lock` endpoint and attestation to be exercised by an implementation before their wording is final.

*Changelog.* Draft 0.7 (2026-09-27): review pass. `oxy status --json` shape (§9.5); stat crawl required and file-system monitor recommended (§12.4); capabilities aligned with the implementation (§16.1); §24 lists the implemented command line and names the reserved commands; new §26.1 reference implementation status; §27 records the open workspace-conflict and lock items.

Draft 0.6s (2026-09-27): the manifest as a stat cache with a racy-stat window (§12.4).

    Status {

        /// Machine-readable output: paths, and every conflict with its kind and contributing changes

        #[arg(long)]

        json: bool,

    },

        Cmd::Status { json } => workspace::status(json),

pub fn status(json: bool) -> Result<i32> {

    if json {

        println!("{}", repo.status_json(&snap)?);

        return Ok(if snap.base_snapshot.is_conflicted() { 2 } else { 0 });

    }