ElyTree: an unborn HEAD is told from a broken one (G-03, in review)

born() takes a HEAD as new only when it names a branch under
refs/heads/ that no ref holds yet; a broken ref, a tag target or any
other state is an error in Git's words. The branch name keeps every
byte. Round 3 is fixed; round 4 waits until 0.1.3 ships.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

apps/ely-tree/src/git.rs

@@ -76,9 +76,25 @@ impl Git {
 
     /// HEAD names a commit; a new repository has none yet.
     pub fn born(&self, dir: &Path) -> io::Result<bool> {
-        Ok(!self
-            .run_or_one(dir, &["rev-parse", "--verify", "-q", "HEAD"])?
-            .is_empty())
+        if !self.run_or_one(dir, &["rev-parse", "--verify", "-q", "HEAD"])?.is_empty() {
+            return Ok(true);
+        }
+        // Unborn: HEAD names a branch with no ref at all.
+        let branch = String::from_utf8(self.run(dir, &["symbolic-ref", "-q", "HEAD"])?)
+            .map_err(|_| io::Error::other("HEAD names a ref that is not UTF-8"))?;
+        // Only Git's line end goes; a name keeps every byte.
+        let branch = branch.strip_suffix('\n').unwrap_or(&branch).to_owned();
+        let found = self.command(dir, &["for-each-ref", "--format=%(refname)", &branch]).output()?;
+        let unborn = branch.starts_with("refs/heads/") && found.status.success();
+        if unborn && found.stdout.is_empty() && found.stderr.is_empty() {
+            return Ok(false);
+        }
+        let mut why = format!("HEAD names {branch}: no commit, and no branch yet to begin");
+        let said = String::from_utf8_lossy(&found.stderr);
+        if !said.trim().is_empty() {
+            why = format!("{why}; Git says {}", said.trim());
+        }
+        Err(io::Error::other(why))
     }
 
     /// Exit 1 is an answer: files differ, key unset.

apps/ely-tree/src/tests/places.rs

@@ -447,6 +447,27 @@ fn a_new_repository_lists_no_moves_and_no_lfs_files() {
         crate::structure::lfs(&git(), &root).expect("no LFS error"),
         Vec::new()
     );
+    // A new branch whose name ends in a no-break space.
+    let named = committed(&dir.path().join("named"));
+    sh(&named, &["branch", "topic"]);
+    sh(&named, &["checkout", "-q", "--orphan", "topic\u{a0}"]);
+    assert_eq!(crate::recover::reflog(&git(), &named).expect("no reflog error"), Vec::new());
+}
+
+#[test]
+fn a_broken_head_is_an_error_not_an_empty_repository() {
+    let dir = tempfile::tempdir().expect("a temp dir");
+    let root = committed(dir.path());
+    let branch = sh(&root, &["symbolic-ref", "--short", "HEAD"]).trim().to_owned();
+    std::fs::write(root.join(".git/refs/heads").join(branch), "not-an-object-id
+").expect("breaks");
+    assert!(crate::recover::reflog(&git(), &root).is_err(), "the reflog says why");
+    assert!(crate::structure::lfs(&git(), &root).is_err(), "LFS says why");
+    // HEAD at a missing tag is no new branch either.
+    let other = dir.path().join("other");
+    crate::repo::init(&git(), &other).expect("init");
+    sh(&other, &["symbolic-ref", "HEAD", "refs/tags/missing"]);
+    assert!(crate::recover::reflog(&git(), &other).is_err(), "a tag HEAD says why");
 }
 
 #[test]