feat: branch-name consistency audit — short names everywhere, like split

Audit of every command that accepts a branch name; the queue/<qname>/
prefix never has to be typed:

- create: in a namespaced queue (explicit name, or branches already
  under queue/<name>/…) a short name creates queue/<qname>/<short>,
  exactly like split's segments. Names containing '/' are used as-is;
  plain-named queues stay plain, so no queue ever mixes conventions.
- create --base, track --parent: short names resolve via a unique
  queue/*/<name> match (ambiguity is an error listing the candidates).
- checkout <branch>: reattaches by short name within the line.
- split: already compliant (the reference behavior).

require_queue_name now reports whether the name was explicit, which is
what decides namespacing for brand-new queues.

Author: freshtonic

src/commands.rs

@@ -236,29 +236,47 @@ pub fn doctor() -> Result<()> {
 pub fn create(name: &str, base: Option<&str>, queue_flag: Option<&str>) -> Result<()> {
     git::ensure_repo()?;
     let trunk = meta::trunk()?;
-    if git::branch_exists(name) {
-        bail!("branch `{name}` already exists");
-    }
     let parent = match base {
         Some(b) => {
-            if !git::branch_exists(b) {
+            let b = resolve_branch_arg(b)?;
+            if !git::branch_exists(&b) {
                 bail!("base branch `{b}` does not exist");
             }
-            b.to_string()
+            b
         }
         None => git::current_branch()?,
     };
     // Every queue is named: inherit when extending, otherwise ask/take one.
-    let qname = if meta::parent(&parent).is_some() {
+    // `namespaced` decides whether the new branch lives under queue/<name>/…:
+    // true when the queue name is explicit or the queue already follows the
+    // convention — so you type short names and never the prefix (as with
+    // split), and plain-named queues stay plain.
+    let (qname, namespaced) = if meta::parent(&parent).is_some() {
         let q = Queue::load()?;
         let line = q.line_through(&parent)?;
         match line_queue_name(&line) {
-            Some(n) => n,
+            Some(n) => {
+                let ns = line
+                    .branches
+                    .first()
+                    .map(|b| b.starts_with("queue/"))
+                    .unwrap_or(false);
+                (n, ns)
+            }
             None => bail!("this queue has no name; run `git queue name <name>` first"),
         }
     } else {
         require_queue_name(queue_flag, name)?
     };
+    let name = if name.contains('/') || !namespaced {
+        name.to_string()
+    } else {
+        format!("queue/{qname}/{name}")
+    };
+    let name = name.as_str();
+    if git::branch_exists(name) {
+        bail!("branch `{name}` already exists");
+    }
     let parent_sha = git::rev_parse(&parent)?;
 
     git::create_branch(name, &parent)?;
@@ -300,10 +318,10 @@ pub fn split(delete_original: bool, queue_flag: Option<&str>) -> Result<()> {
     let qname = if queue.is_tracked(&branch) {
         match line_queue_name(&queue.line_through(&branch)?) {
             Some(n) => n,
-            None => require_queue_name(queue_flag, &branch)?,
+            None => require_queue_name(queue_flag, &branch)?.0,
         }
     } else {
-        require_queue_name(queue_flag, &branch)?
+        require_queue_name(queue_flag, &branch)?.0
     };
 
     let commits = git::commits_between(&base, &branch)?;
@@ -513,7 +531,7 @@ pub fn track(
         bail!("working tree has uncommitted changes; commit or stash them before `track --split`");
     }
     let parent = match parent {
-        Some(p) => p,
+        Some(p) => resolve_branch_arg(&p)?,
         None => trunk.clone(),
     };
     if !git::branch_exists(&parent) {
@@ -534,7 +552,7 @@ pub fn track(
         let line = q.line_through(&branch)?;
         match line_queue_name(&line) {
             Some(n) => n,
-            None => require_queue_name(queue_flag, &branch)?,
+            None => require_queue_name(queue_flag, &branch)?.0,
         }
     };
     meta::set_branch_queue(&branch, &qname)?;
@@ -1358,10 +1376,10 @@ fn line_queue_name(line: &Line) -> Option<String> {
 /// Ask for (or take) a queue name, mandatorily. Order: explicit flag, TTY
 /// prompt, then — non-interactive with no flag — a fallback so scripts keep
 /// working, announced loudly.
-fn require_queue_name(flag: Option<&str>, fallback: &str) -> Result<String> {
+fn require_queue_name(flag: Option<&str>, fallback: &str) -> Result<(String, bool)> {
     if let Some(n) = flag {
         meta::validate_queue_name(n)?;
-        return Ok(n.to_string());
+        return Ok((n.to_string(), true));
     }
     if std::io::IsTerminal::is_terminal(&std::io::stdin()) {
         print!("Name this queue: ");
@@ -1372,13 +1390,31 @@ fn require_queue_name(flag: Option<&str>, fallback: &str) -> Result<String> {
         let answer = answer.trim().to_string();
         if !answer.is_empty() {
             meta::validate_queue_name(&answer)?;
-            return Ok(answer);
+            return Ok((answer, true));
         }
     }
     let fallback = fallback.replace('/', "-");
     meta::validate_queue_name(&fallback)?;
     eprintln!("note: queue named `{fallback}` (rename any time with `git queue name <name>`).");
-    Ok(fallback)
+    Ok((fallback, false))
+}
+
+/// Resolve a branch argument, accepting short names inside namespaced queues:
+/// an exact branch name wins; otherwise a unique `queue/*/<arg>` match does.
+fn resolve_branch_arg(arg: &str) -> Result<String> {
+    if git::branch_exists(arg) {
+        return Ok(arg.to_string());
+    }
+    let suffix = format!("/{arg}");
+    let matches: Vec<String> = meta::tracked_branches()
+        .into_iter()
+        .filter(|b| b.ends_with(&suffix))
+        .collect();
+    match matches.as_slice() {
+        [one] => Ok(one.clone()),
+        [] => Ok(arg.to_string()), // let the caller produce its natural error
+        many => bail!("`{arg}` is ambiguous: {}", many.join(", ")),
+    }
 }
 
 /// The outcome of reconciling one line's PRs.
@@ -1954,8 +1990,16 @@ pub fn checkout(arg: &str) -> Result<()> {
     };
     let top = line.branches.last().unwrap().clone();
 
-    // Checking out a branch of the line reattaches and ends the session.
-    if line.branches.iter().any(|b| b == arg) || arg == line.base {
+    // Checking out a branch of the line reattaches and ends the session
+    // (short names resolve inside namespaced queues).
+    let reattach = line
+        .branches
+        .iter()
+        .find(|b| *b == arg || b.ends_with(&format!("/{arg}")))
+        .cloned()
+        .or_else(|| (arg == line.base).then(|| line.base.clone()));
+    if let Some(target) = reattach {
+        let arg = target.as_str();
         if !git::tracked_clean() {
             bail!("stage or tracked files have changes; commit or stash them first");
         }

src/lib.rs

@@ -34,7 +34,7 @@ struct Cli {
 enum Command {
     /// Create a new branch queued after the current one.
     #[command(
-        long_about = "Creates `<name>` at the current branch's tip (or at `--base <branch>`'s tip) and records it as the next branch of the queue. Extending a queue inherits its name; starting a new one asks for a name (or takes `--queue`). The front PR of a queue targets its base branch — which is how queues can be built on release or bugfix branches, not just trunk. Make commits, then `git queue submit` opens the numbered PRs."
+        long_about = "Creates the next branch of the queue at the current branch's tip (or at `--base <branch>`'s tip). In a namespaced queue — one with an explicit name, or whose branches already live under queue/<name>/… — you give the short name and the branch is created as queue/<name>/<short>, exactly like split's segments; names containing `/` are used as-is, and plain-named queues stay plain. Extending a queue inherits its name; starting a new one asks (or takes `--queue`). The front PR targets the base branch, which is how queues can be built on release branches. Branch arguments elsewhere (`--base`, `track --parent`, `checkout`) accept the same short names."
     )]
     Create {
         /// Name of the new branch.

tests/integration.rs

@@ -1670,3 +1670,59 @@ fn setup_yes_installs_hooks_and_gate_and_undo_reverses() {
         .unwrap();
     assert!(!gate.status.success(), "gate should be unset");
 }
+
+#[test]
+fn create_namespaces_branches_and_short_names_resolve() {
+    let tmp = new_repo();
+    let dir = tmp.path();
+    // Explicit queue name => namespaced branches from short names.
+    queue(dir)
+        .args(["create", "fix-a", "--queue", "pay"])
+        .assert()
+        .success();
+    assert_eq!(
+        git_out(dir, &["rev-parse", "--abbrev-ref", "HEAD"]),
+        "queue/pay/fix-a"
+    );
+    commit(dir, "a.txt");
+    // Extending inherits the namespace, still from a short name.
+    queue(dir).args(["create", "fix-b"]).assert().success();
+    assert_eq!(
+        git_out(dir, &["rev-parse", "--abbrev-ref", "HEAD"]),
+        "queue/pay/fix-b"
+    );
+    assert_eq!(
+        git_out(dir, &["config", "branch.queue/pay/fix-b.queueParent"]),
+        "queue/pay/fix-a"
+    );
+    commit(dir, "b.txt");
+
+    // checkout reattaches by short name.
+    let c = sha(dir, "queue/pay/fix-a");
+    queue(dir).args(["checkout", &c]).assert().success();
+    queue(dir).args(["checkout", "fix-b"]).assert().success();
+    assert_eq!(
+        git_out(dir, &["rev-parse", "--abbrev-ref", "HEAD"]),
+        "queue/pay/fix-b"
+    );
+
+    // track --parent resolves a short name too.
+    git(dir, &["checkout", "-q", "-b", "hotfix", "queue/pay/fix-b"]);
+    commit(dir, "h.txt");
+    queue(dir)
+        .args(["track", "--parent", "fix-b", "--no-stamp-ids"])
+        .assert()
+        .success();
+    assert_eq!(
+        git_out(dir, &["config", "branch.hotfix.queueParent"]),
+        "queue/pay/fix-b"
+    );
+
+    // Plain-named queues stay plain (fallback naming, no prefix).
+    git(dir, &["checkout", "-q", "main"]);
+    queue(dir).args(["create", "plain"]).assert().success();
+    assert_eq!(
+        git_out(dir, &["rev-parse", "--abbrev-ref", "HEAD"]),
+        "plain"
+    );
+}