fix(tui): retry a skipped branch read and keep the last label

A turn-end refresh that overlapped an in-flight lookup was dropped, so
the border kept a stale branch until a later turn. Remember one
follow-up and run it when the lookup settles. A null result after a
known branch is a timeout or failure, not a reason to clear the suffix.

Author: TheGreatAxios

src/tui/runner-host.test.ts

@@ -120,6 +120,30 @@ describe("mountRunnerHost branch label", () => {
       },
     );
   });
+
+  test("a null git result after a known branch leaves the previous suffix", async () => {
+    const emitter = new EventEmitter();
+    let branch: string | null = "main";
+    await withRunnerHost(
+      async (host) => {
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(ruleOf(host.shell.promptBottomRule)).toContain("(main)");
+
+        branch = null;
+        emitter.emit("event", { type: "inference.done" });
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(host.shell.workspace.branch).toBe("main");
+        expect(ruleOf(host.shell.promptBottomRule)).toContain("(main)");
+      },
+      {
+        eventEmitter: emitter,
+        cwd: "/repo",
+        fetchBranch: async () => branch,
+      },
+    );
+  });
 });
 
 function session(over: Partial<SubAgentSession>): SubAgentSession {

src/tui/workspace-watch.test.ts

@@ -23,12 +23,13 @@ describe("watchGitBranch", () => {
     watch.stop();
   });
 
-  test("skips a refresh while the previous lookup is still outstanding", async () => {
+  test("one refresh during an outstanding lookup runs a single follow-up and reports the later branch", async () => {
     let calls = 0;
     const pending: ((branch: string | null) => void)[] = [];
+    const seen: (string | null)[] = [];
     const watch = watchGitBranch({
       cwd: "/repo",
-      onBranch: () => undefined,
+      onBranch: (b) => seen.push(b),
       fetchBranch: () => {
         calls += 1;
         return new Promise((resolve) => {
@@ -42,8 +43,29 @@ describe("watchGitBranch", () => {
 
     pending[0]?.("main");
     await flush();
-    watch.refresh();
     expect(calls).toBe(2);
+    expect(seen).toEqual(["main"]);
+
+    pending[1]?.("topic");
+    await flush();
+    expect(calls).toBe(2);
+    expect(seen).toEqual(["main", "topic"]);
+    watch.stop();
+  });
+
+  test("a null result after a known branch is not reported", async () => {
+    const seen: (string | null)[] = [];
+    let branch: string | null = "main";
+    const watch = watchGitBranch({
+      cwd: "/repo",
+      onBranch: (b) => seen.push(b),
+      fetchBranch: async () => branch,
+    });
+    await flush();
+    branch = null;
+    watch.refresh();
+    await flush();
+    expect(seen).toEqual(["main"]);
     watch.stop();
   });
 

src/tui/workspace-watch.ts

@@ -5,10 +5,14 @@
  * interval used to fork `git rev-parse` every few seconds for the whole TUI
  * lifetime, including idle. Callers refresh on an event that can change the
  * branch (a finished turn); staleness between those events is acceptable.
- * While a lookup is outstanding a refresh is skipped, so a git process hung
- * on a network filesystem cannot accumulate children. A lookup that lands
- * after stop is dropped. Nothing here blocks a paint — the border keeps the
- * last branch it was given, including across a failed lookup.
+ * A refresh that arrives while a lookup is outstanding is remembered and
+ * runs once that lookup settles: one follow-up child, not a loop, and not
+ * a dropped turn-end read. A lookup that lands after stop is dropped.
+ * Nothing here blocks a paint. The border keeps the last branch it was
+ * given across a rejected lookup and across a null result: `getGitBranch`
+ * resolves null for timeout, a non-zero exit, and a non-repo, and that
+ * must not be treated as detached HEAD clearing the suffix. A null before
+ * any branch was shown still reports, so a non-repo stays unlabeled.
  */
 
 import { getGitBranch } from "../agent/environment.js";
@@ -33,17 +37,31 @@ export function watchGitBranch(input: BranchWatchInput): BranchWatch {
   const fetchBranch = input.fetchBranch ?? getGitBranch;
   let inFlight = false;
   let stopped = false;
+  let again = false;
+  let shown: string | null = null;
 
   const refresh = (): void => {
-    if (inFlight || stopped) return;
+    if (stopped) return;
+    if (inFlight) {
+      again = true;
+      return;
+    }
     inFlight = true;
+    again = false;
     fetchBranch(input.cwd).then(
       (branch) => {
+        // Null after a real branch is a failed lookup (or detached HEAD, which
+        // shares that null). Keep the suffix; do not clear it.
+        if (!stopped && !(branch === null && shown !== null)) {
+          shown = branch;
+          input.onBranch(branch);
+        }
         inFlight = false;
-        if (!stopped) input.onBranch(branch);
+        if (!stopped && again) refresh();
       },
       () => {
         inFlight = false;
+        if (!stopped && again) refresh();
       },
     );
   };