Git import: shared graphs, deterministic node ids; quieter status dfb23a3a8cfa

        let mut report = GitImportReport::default();

        let mut known = self.git_known(git_dir)?;

        let old_heads = self.bookmark_heads()?;

        // The state and Git tree of imported commits whose first-parent

        // children are still to come, so a child starts from its parent's

        // state instead of rebuilding it from history. The last child takes

        // child of an evicted one rebuilds).

        let mut waiting: HashMap<&str, usize> = HashMap::new();

        for gc in &commits {

            if let Some(p1) = gc.parents.first() {

                    Some(c) => c.clone(),

                    None => {

                        let c = cat.read(&sha)?;

                            blob_cache.clear();

                            cache_bytes = 0;

                        }

                }

            }

            lap(3, &mut clock);

            let mut built =

            lap(4, &mut clock);

            // A file or submodule with several live blobs (branches that

            // replaced it independently) is resolved to the commit's blob:

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

            change.normalize();

            let hash = self.store.put_change(&change)?;

            base.add_unchecked(change);

            known.imported.insert(gc.sha.clone(), hash);

            if waiting.get(gc.sha.as_str()).is_some_and(|n| *n > 0) {

                kept.insert(gc.sha.clone(), (base, tree));

                kept_order.push_back(gc.sha.clone());

                    if let Some(old) = kept_order.pop_front() {

                        kept.remove(&old);

                    }

        if last.is_none() {

            return Ok(report);

        }

        report.heads = heads.len();

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

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

}

impl Repo {

        self.oxy

            .join("workspaces")

            .join(self.workspace.to_hex())

            .duration_since(UNIX_EPOCH)

            .map(|d| d.as_nanos())

            .unwrap_or(0);

            conflicted as u8, uncommitted as u8

        );

        for (path, e) in entries {

            let full = self.root.join(path);

            let (size, mtime_ns) = match fs::symlink_metadata(&full) {

                None => blake3::hash(&e.content).to_hex().to_string(),

            };

            let blob = blobs.get(path).copied().or(e.blob);

                path,

                size,

                mtime_ns,

            ));

        }

        let p = self.manifest_path();

        fs::create_dir_all(p.parent().unwrap())?;

        write_atomic(&p, text.as_bytes())

    }

        fs_entries: &BTreeMap<String, FsEntry>,

        resolve: &HashSet<String>,

    ) -> Result<BuiltChange> {

        // Attributes come from the files being committed, so a new

        // `.oxyattributes` applies to the same change that adds it.

        let attrs = crate::attributes::Attributes::from_files(

        );

        let mut b = ChangeBuilder::new(base, base_snapshot, reuse).with_attributes(attrs);

        b.resolve = resolve.clone();

        // Rename detection (spec §7.1, §23): a removed file and an added file

        // of the same kind whose contents are at least half alike become one

        // move of the same node, so identity survives across the rename.

}

/// Builds the tree ops and edits of a working-copy change against a base.

struct ChangeBuilder<'a> {

    base: &'a State,

    base_snapshot: &'a Snapshot,

    blobs: HashMap<String, ObjectRef>,

    /// Opaque files whose replace conflict the content settles.

    resolve: HashSet<String>,

}

impl<'a> ChangeBuilder<'a> {

            attrs: crate::attributes::Attributes::default(),

            blobs: HashMap::new(),

            resolve: HashSet::new(),

        }

    }

            crate::attributes::normalize_eol(content)

        } else {

            content.to_vec()

        }

    }

    fn reused_node(&self, path: &str, kind: NodeKind) -> Option<NodeId> {

            parent = match self.dir_nodes.get(&prefix) {

                Some(n) => *n,

                None => {

                    self.tree_ops.push(TreeOp::AddNode {

                        node,

                        kind: NodeKind::Dir,

    fn add_path(&mut self, repo: &Repo, path: &str, e: &FsEntry) -> Result<()> {

        let (dir, name) = split_path(path);

        let parent = self.ensure_dir(dir);

        let opaque = self.opaque_for(path, e);

        let nocompress = self.attrs.lookup(path).nocompress;

        self.tree_ops.push(TreeOp::AddNode {

        .unwrap()

        .with_home(root.join("home"));

    repo2.import_git(&g, "main").unwrap();

    let ids: BTreeSet<ChangeId> = repo

        .log()

        .unwrap()

    assert_eq!(repo.receipts(&heads).unwrap().len(), 1);

    assert_eq!(repo.read_blob(&out).unwrap(), b"built\n");

    assert!(repo.fsck().unwrap().problems.is_empty());

}

pub struct State {

    changes: HashMap<ChangeHash, ChangeMeta>,

    tree: TreeGraph,

    replaces: HashMap<NodeId, Vec<ReplaceRecord>>,

    /// Memoised transitive dependencies. A mutex, not a `RefCell`, so a

    /// loaded state can be shared across threads by a host that caches it.

                node.short(12)

            );

        }

    }

    /// Operations over every file need every graph.

                Ok((node, graph))

            })

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

        Ok(())

    }

    pub fn checkpoint_file_graphs(&self) -> Vec<(NodeId, Vec<u8>)> {

        use rayon::prelude::*;

        self.require_full("a checkpoint");

        nodes.sort_by_key(|(n, _)| **n);

        nodes

            .into_par_iter()

                Ok((*node, graph))

            })

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

        Ok(st)

    }

            }

            for (node, edits) in per_node {

                match self.files.get_mut(&node) {

                    None => deferred.entry(node).or_default().edits.push((h, edits)),

                }

            }

                    let idx = counters.entry(node).or_default();

                    let first = *idx;

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

                        h,

                        first,

                        vertex(after.resolve(h)),

                    );

                }

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

                    for r in atoms {

                        g.delete(h, &r.resolve(h));

                    }

| | |

|---|---|

| **Format version** | 1 |

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

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

`oxy git import <repo>` and `oxy git export <repo>` provide a lossless-enough bridge; `oxy git fetch/push` operate against a Git remote directly.

- **Export.** Each state along a bookmark becomes a Git commit whose tree is the materialized state. The ChangeId is written as a `Change-Id:` trailer and the ChangeHash as `Oxy-Hash:`. Conflicted states are exported with §9.5 markers and an `Oxy-Conflicted: true` trailer. Signatures are not exported; Git commits MAY be additionally signed with the Ed25519 key via SSH signature format.

- **Fetch and push against a Git remote.** `oxy git fetch URL` keeps a bare mirror under `.oxy/git/` for the remote, fetches the branch into it, and imports the commits the bookmark does not have yet, seeding the import with the commits already known: an imported commit maps to its change, and a commit this repository exported maps to the bookmark state it was made from (so a Git commit on top of exported work is based on everything that work contained, including changes Git never saw). The bookmark moves to the union of its heads and the new changes, like a pull; the working copy follows when it was clean. A fetched state whose previous state was itself a Git tree is remembered as equal to the fetched tip. `oxy git push URL` refuses until the remote's tip is known, exports the bookmark's later states as commits chained onto that tip, and pushes the branch, so the push is always a fast-forward.

- **Submodules.** A Git gitlink entry (mode `160000`) imports as a `subrepo` node with a Git pin (§7.8) and the matching `.gitmodules` entry becomes a `.oxymodules` entry with `branch` set to the submodule's configured branch when there is one. Export writes a Git pin back as a gitlink, keeps a tracked `.gitmodules` as is, and otherwise derives `.gitmodules` from `.oxymodules`; an Oxygen pin has no Git form and is omitted from the exported tree, which the export report counts.

---

Draft 0.8i (2026-09-28): portability rules for exec bits and path names (§7.7); found by verifying a real Git import commit by commit: deletions depend on the inserters of the lines right after them, and replacements on the change that set their old blob (§8.1); replace records are superseded causally, so a reverted binary keeps its blob (§9.3); merges resolve opaque conflicts to the commit's blob, and `oxy git verify` (§23). Draft 0.8h (2026-09-28): `oxy fsck` (§21.1); durability rules and the operation head as commit point (§13.6); the operation head moves by compare-and-swap and concurrent operations are merged (§12.1); `oxy doctor` (§21.2). Draft 0.8g (2026-09-27): delegates of a rule's identities may sign reference attestations (§14.5); local-path pushes bind unbound repositories like HTTP ones. Draft 0.8f (2026-09-27): challenge signatures (§14.3) for hosts. Draft 0.8e (2026-09-27): anonymous changes (zero author) are authenticated by a seal from any key, so imported and pre-identity history can be pushed under a policy (§14.4). Draft 0.8d (2026-09-27): unbound hosted repositories adopt the first pusher's id (§16.1). Draft 0.8c (2026-09-27): bare repositories (`oxy init --bare`, §12.2: no workspace, no working copy; hosting) and the reference server as an embeddable library (§15.1). Draft 0.8b (2026-09-27): the machine interface for editors (§24): `root`, `cat`, `version`, `hunks`, `discard`, and `--json` on the reporting commands.

            json::obj([

                ("name", json::s(name)),

                ("url", json::s(url)),

                ("bookmarks", bms.unwrap_or_else(|| "[]".into())),

            ])

        });