herdr: put both agents on one tab, side by side

  tab 1 "review"   orbit-diff, the whole tab
  tab 2 "agents"   claude │ codex, an even left/right split
  tab 3 "setup"    the provisioning script

The agents are a pair you compare, so having both on screen beats tabbing
between them. That's now the only split in the workspace — everything else
still gets a whole tab, which is the point of the previous change.

A failed split leaves the workspace tagged and returned, same as every other
half-built case, so `d` and `orbit-diff reset` can still close it. Test added
for that path since it's a new way for the build to die partway.

tmux unchanged and re-verified.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: diagonalbot

README.md

@@ -296,18 +296,18 @@ it drives herdr, which is the one that owns the window it would build. Set
 `ORBIT_MUX=tmux|herdr` to force a backend.
 
 **The review environment is shaped differently.** Under tmux a review is one
-window of four panes. Under herdr it's a **workspace of four single-pane tabs**:
+window of four panes. Under herdr it's a **workspace of three tabs**:
 
 ```
 tab 1 "review"   orbit-diff, the whole tab
-tab 2 "claude"   the Claude CLI
-tab 3 "codex"    the Codex CLI      (set `pr.codex`)
-tab 4 "setup"    your provisioning script
+tab 2 "agents"   claude │ codex, side by side   (set `pr.codex`)
+tab 3 "setup"    your provisioning script
 ```
 
-Nothing is split. Each of these is something you sit in and use full-size — a
-diff wants the width, an agent is a conversation, build output scrolls — so
-slicing a tab into thirds only made all three worse.
+The agents share a tab because they're a pair you compare — both on screen beats
+tabbing between them. Everything else gets a whole tab: a diff wants the width,
+build output scrolls. That's the only split, and slicing tab 1 into thirds as
+well only made all three of its occupants worse.
 
 There's no `orbit-diff pr-status` panel under herdr: the viewer's `G` overview
 covers the same ground with room to render it, and the provisioned environment

src/herdr.mjs

@@ -532,13 +532,14 @@ export function createHerdrBackend({ run = defaultRun, env = process.env, resolv
   // tabs:
   //
   //   tab 1 "review"  orbit-diff, the whole tab
-  //   tab 2 "claude"  the Claude CLI
-  //   tab 3 "codex"   the Codex CLI
-  //   tab 4 "setup"   the provisioning script
+  //   tab 2 "agents"  claude │ codex, side by side
+  //   tab 3 "setup"   the provisioning script
   //
-  // No splits at all. Each of these is something you sit in and use full-size —
-  // a diff wants the width, an agent is a conversation, and build output scrolls
-  // — so slicing the first tab into thirds only made all three worse.
+  // The only split left is the one between the two agents, and it earns its
+  // place: they're a pair you compare, so having both on screen beats tabbing
+  // between them. Everything else gets a whole tab — a diff wants the width,
+  // build output scrolls — which is why slicing tab 1 into thirds made all
+  // three of its occupants worse.
   //
   // There used to be a fifth thing here, an `orbit-diff pr-status` pane showing
   // branch/PR/checks/env. The viewer's `G` overview covers all of it and more,
@@ -575,12 +576,28 @@ export function createHerdrBackend({ run = defaultRun, env = process.env, resolv
     tag(diffPane, "diff", worktreePath);
 
     const panes = { diff: diffPane };
-    for (const [role, label] of [["claude", "claude"], ["codex", "codex"], ["setup", "setup"]]) {
-      const tab = addTab(window, worktreePath, label);
-      if (tab.error) return { error: tab.error, window };
-      tag(tab.pane, role, worktreePath);
-      panes[role] = tab.pane;
-    }
+
+    // Tab 2: both agents, an even left/right split.
+    const agents = addTab(window, worktreePath, "agents");
+    if (agents.error) return { error: agents.error, window };
+    tag(agents.pane, "claude", worktreePath);
+    panes.claude = agents.pane;
+
+    const right = run([
+      "pane", "split", agents.pane, "--direction", "right", "--ratio", "0.50",
+      "--cwd", worktreePath, "--no-focus",
+    ]);
+    if (right.status !== 0) return { error: (right.stderr || "herdr pane split failed").trim(), window };
+    const codexPane = idFrom(right.stdout, ["pane_id", "id"], { bare: true });
+    if (!codexPane) return { error: "couldn't parse the herdr pane id", window };
+    tag(codexPane, "codex", worktreePath);
+    panes.codex = codexPane;
+
+    // Tab 3: the provisioning script.
+    const setup = addTab(window, worktreePath, "setup");
+    if (setup.error) return { error: setup.error, window };
+    tag(setup.pane, "setup", worktreePath);
+    panes.setup = setup.pane;
 
     if (diffCmd) runInPane(panes.diff, diffCmd);
     if (claudeCmd) runInPane(panes.claude, claudeCmd);

src/herdr.test.mjs

@@ -7,7 +7,7 @@ import { sessionKey } from "./session.mjs";
 // for the CLI. That covers the argument-building and parsing — the parts we can
 // be sure about — and deliberately not the parts that depend on a live server.
 //
-// A worktree's review is a herdr WORKSPACE of four tabs, so "window" ids in
+// A worktree's review is a herdr WORKSPACE of three tabs, so "window" ids in
 // this backend are workspace ids. See the header of herdr.mjs for why.
 
 const IN_HERDR = { HERDR_PANE_ID: "w1:p1" };
@@ -338,7 +338,7 @@ function buildingHerdr({ focusedAfter = null } = {}) {
   return { run, calls };
 }
 
-test("a review is a workspace of four single-pane tabs", () => {
+test("a review is a workspace of three tabs, agents sharing the middle one", () => {
   const { run, calls } = buildingHerdr();
   const built = createHerdrBackend({ run, env: IN_HERDR }).buildReviewWindow({
     worktreePath: "/wt/feature",
@@ -353,16 +353,19 @@ test("a review is a workspace of four single-pane tabs", () => {
   expect(built.window).toBe("w5"); // the workspace
   expect(Object.keys(built.panes).sort()).toEqual(["claude", "codex", "diff", "setup"]);
 
-  // Nothing is split any more: every tab is one full-size pane. A diff wants
-  // the width, an agent is a conversation, build output scrolls.
-  expect(calls.filter((c) => c[1] === "split")).toHaveLength(0);
-
-  // The workspace's own first tab is the diff; the other three are created.
+  // The workspace's own first tab is the diff; two more are created.
   expect(built.panes.diff).toBe("w5:p1");
   const tabs = calls.filter((c) => is("tab", "create")(c));
-  expect(tabs.map((t) => t[t.indexOf("--label") + 1])).toEqual(["claude", "codex", "setup"]);
+  expect(tabs.map((t) => t[t.indexOf("--label") + 1])).toEqual(["agents", "setup"]);
   for (const t of tabs) expect(t[t.indexOf("--workspace") + 1]).toBe("w5");
 
+  // Exactly one split, and it's the agents' tab down the middle.
+  const splits = calls.filter((c) => c[1] === "split");
+  expect(splits).toHaveLength(1);
+  expect(splits[0][2]).toBe(built.panes.claude); // claude keeps the left
+  expect(splits[0]).toContain("right");
+  expect(splits[0][splits[0].indexOf("--ratio") + 1]).toBe("0.50");
+
   // Every command lands in the right place.
   const ran = calls.filter((c) => c[1] === "run").map((c) => [c[2], c[3]]);
   expect(ran).toEqual([
@@ -373,6 +376,22 @@ test("a review is a workspace of four single-pane tabs", () => {
   ]);
 });
 
+test("a failed agent split reports the workspace so it can still be closed", () => {
+  const calls = [];
+  const run = (args) => {
+    calls.push(args);
+    if (is("workspace", "create")(args)) {
+      return { status: 0, stdout: reply("workspace_create", { workspace_id: "w5", pane_id: "w5:p1" }), stderr: "" };
+    }
+    if (is("tab", "create")(args)) return { status: 0, stdout: reply("tab_create", { pane_id: "w5:t1p" }), stderr: "" };
+    if (args[1] === "split") return { status: 1, stdout: "", stderr: "no room" };
+    return { status: 0, stdout: "", stderr: "" };
+  };
+  const built = createHerdrBackend({ run, env: IN_HERDR }).buildReviewWindow({ worktreePath: "/wt/x" });
+  expect(built.error).toBe("no room");
+  expect(built.window).toBe("w5");
+});
+
 // The pr-status pane is gone: `G` covers it, with room to render it properly.
 test("no status pane is built, and a statusCmd is ignored rather than run", () => {
   const { run, calls } = buildingHerdr();