submodule status and doctor before the first commit e7ac6c2e84e4

            // Before the first commit the identity object is stored nowhere

            // yet; with its secret key at hand that is normal.

            Err(_)

                if self

                    .keys_dir

                    .join(format!("{}.secret", key.to_hex()))

                    .is_file() =>

            {

                rep.push(

                    "identity",

                    Health::Ok,

                    format!(

                        "identity {} has its secret key; it is stored in the repository with your first signed change",

                        key.short(12)

                    ),

                    None,

                );

                return;

            }

    /// Whether the working copy's base records it. An added subrepo

    /// (registered in `.oxymodules`, not committed yet) has `pin` set to

    /// what the next commit records.

    pub committed: bool,

                committed: true,

            });

        }

        // Registered but not committed yet: pinned at what they are now.

        for (path, m) in &modules.entries {

            if snap.files.contains_key(path) {

                continue;

            }

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

            let Ok(pin) = read_pin(&dir, m.bookmark.as_deref()) else {

                continue;

            };

            out.push(SubrepoInfo {

                path: path.clone(),

                pin: pin.clone(),

                url: Some(m.url.clone()),

                actual: Some(pin),

                dirty: nested_dirty(&dir).unwrap_or(false),

                committed: false,

        out.sort_by(|a, b| a.path.cmp(&b.path));

/// Doctor and subrepos before the first commit (feedback 5 and 8): a

/// user identity not stored in a new repository yet is fine while its

/// secret key is there; an added subrepo is listed as not committed yet.

#[test]

fn a_new_repository_is_healthy_before_its_first_commit() {

    hermetic();

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

    let root = dir.path();

    let home = root.join("home");

    let mut first = Repo::init(&root.join("first"))

        .unwrap()

        .with_home(home.clone());

    let (key, _) = first

        .create_identity("Ada", "[email protected]", IdentityScope::User)

        .unwrap();

    let repo = Repo::init(&root.join("second"))

        .unwrap()

        .with_home(home.clone());

    // Only the secret key: no identity object anywhere this repository sees.

    let keys = repo.keys_dir.clone();

    let _ = fs::remove_file(keys.join(format!("{}.identity", key.to_hex())));

    assert!(keys.join(format!("{}.secret", key.to_hex())).is_file());

    let r = repo.doctor(true);

    let id = r.checks.iter().find(|c| c.area == "identity").unwrap();

    assert_eq!(id.health, Health::Ok, "{}", id.message);

    assert!(id.message.contains("first signed change"), "{}", id.message);

    // A subrepo added and not committed yet is listed, pinned where it is.

    let lib = root.join("lib");

    let l = Repo::init(&lib).unwrap().with_home(home.clone());

    write(&lib, "x.txt", b"x\n");

    l.commit("x", &[]).unwrap();

    let second = root.join("second");

    write(&second, "a.txt", b"a\n");

    repo.submodule_add(&lib.to_string_lossy(), "deps/lib", None)

        .unwrap();

    let subs = repo.subrepos().unwrap();

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

    assert_eq!(

        (subs[0].path.as_str(), subs[0].committed),

        ("deps/lib", false)

    );

    assert_eq!(subs[0].actual.as_ref(), Some(&subs[0].pin));

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

    let subs = repo.subrepos().unwrap();

    assert!(subs[0].committed, "committed now");

}

- [x] M9b `submodule status` shows added-but-unpinned and has `--json` (5, 7); doctor before the first commit (8).

`oxy submodule add URL PATH [--bookmark NAME]` clones URL into PATH (an Oxygen remote when URL answers as one, otherwise Git), records `.oxymodules`, and the next snapshot adds the node pinned at the clone's heads. `oxy submodule update [--init] [PATH..]` brings nested repositories to their pins. `oxy submodule status` lists each subrepo with its pin and whether the nested repository matches it; one registered but not committed yet is listed as added, with the pin the next commit records (`committed: false` in `--json`). `oxy submodule remove PATH` drops the `.oxymodules` entry and records that the node is to go with the next snapshot; the directory is left in place and thereafter ignored as unregistered.

                    ("committed", json::b(s.committed)),

            _ if !s.committed => {

                ui::warn(format!("{} added, not committed yet", ui::glyph("+", "+")))

            }