Give a dock workspace card two rows that say two different things

The dock's cards were three rows tall and spent most of that space
repeating themselves. The name row carried a project tag next to a name
usually derived from that same project; the middle row put the branch
and the git summary into a *single* right-aligned group, so the branch
floated in the middle of the card instead of starting at its left edge;
and the third row was the PR badge, blank on every workspace without a
PR. Five screen rows per workspace, for about two rows of information.

A card is now two rows, each one "what it is" on the left and "how it's
doing" flush right, so the status of every workspace lines up in one
column down the dock:

  ╭──────────────────────────────╮
  │ * fresh-27            ↑2 +14 │
  │ ▸ fix/wrapped-nav   PR #2784 │
  ╰──────────────────────────────╯

The second row never repeats the first: the branch takes it only when it
differs from the workspace name (a worktree's branch usually *is* the
name), otherwise the project does, and when that would echo the name too
— a plain folder opened as its own workspace — the row stays empty.
`(detached)` is now reserved for a real repo with no branch instead of
labelling every non-git folder. A being-created workspace keeps its
whole status message on row two, with the retry key moved up to row
one's right slot.

The alignment itself is host-side: a card row can now carry
`align: "between"` plus the byte offset where its two groups meet, and
`render_tree_card` — which alone knows the card's real width, responsive
or dragged — inserts the gap, always keeping at least one column so the
groups can't run together on a narrow dock.

Author: claude

CHANGELOG.md

@@ -34,6 +34,8 @@ Keyboard and mouse input is now parsed by our own `fresh-input-parser` crate ins
   * Codex "Auto mode" works again (it was passing a flag recent Codex CLI rejects).
   * Dock rows are fully clickable in compact (list) view, ordered by recency, and auto-name themselves from their terminal.
   * Fixed a crash when navigating to an unreachable remote workspace.
+  * Searching the dock and then opening one of the matches no longer wipes the search — the filtered list is still there when you come back for the next one. Leaving the dock (`Esc`, clicking the editor) still clears it.
+  * **Tidier workspace cards** - a card is now two rows instead of three: name with its git summary flush right, then the branch with the PR badge flush right. The branch starts at the card's left edge rather than floating mid-row, the empty third row is gone, and a branch that just repeats the workspace name gives its place to the project.
 * **Terminal**
   * Scrollback no longer loses output or gets stuck mid-scroll (#2649, reported by @dmknght).
 * **Tabs & splits**

crates/fresh-editor/plugins/orchestrator.ts

@@ -1368,17 +1368,69 @@ function sessionNodeEntry(id: number, activeId: number): TextPropertyEntry {
 }
 
 // The dock's "card" density renders each session leaf as a fixed
-// 3-content-row card inside the tree; with `cardBorders` the host
-// wraps those rows in a rounded `╭─…─╮` border (5 screen rows total),
-// restoring the modal picker's pill look: line 1 = glyph · [facet] ·
-// NAME + project; line 2 = branch + git summary (right-aligned against
-// the card border); line 3 = PR badge (blank when none).
-const DOCK_CARD_HEIGHT = 3;
+// 2-content-row card inside the tree; with `cardBorders` the host wraps
+// those rows in a rounded `╭─…─╮` border (4 screen rows total). Two
+// rows, each one "what it is" on the left and "how it's doing" flush
+// right, so the status columns line up down the dock:
+//
+//   ╭──────────────────────────────╮
+//   │ * fresh-27            ↑2 +14 │   name              git
+//   │ ▸ fix/wrapped-nav   PR #2784 │   branch / project  PR
+//   ╰──────────────────────────────╯
+//
+// It was three rows: the third held the PR badge and stood empty on
+// every session without one, and the branch shared the middle row with
+// the git summary as a single right-aligned group — which left it
+// floating in the middle of the card instead of starting at the left
+// edge. The name-repeating branch (a worktree branch usually *is* the
+// workspace name) and the project tag beside the name were dropped for
+// the same reason: they spent a card's scarce width on what the row
+// already said.
+const DOCK_CARD_HEIGHT = 2;
+
+// A card row split into a left group and a right group flush against
+// the card's right border. Tree card rows are plain text entries (no
+// host flex spacer like the modal pill's `flexLine`), so the split
+// point rides along as a byte offset and the host's `render_tree_card`
+// — which knows the card's *actual* inner width, responsive or dragged
+// — inserts the gap. Plugin-side padding could only estimate that width
+// and drifted at every other one.
+function cardSplitRow(left: Entry[], right: Entry[]): TextPropertyEntry {
+  const row = styledRow([...left, ...right] as Parameters<typeof styledRow>[0]);
+  if (right.length === 0) return row;
+  row.properties = {
+    align: "between",
+    splitByte: left.reduce((n, e) => n + utf8Len(e.text), 0),
+  };
+  return row;
+}
+
+// Truncate to `cols` display columns, ellipsising when it doesn't fit.
+// Code-point aware (`Array.from`), so a multi-byte name can't be cut
+// mid-character.
+function capText(s: string, cols: number): string {
+  const chars = Array.from(s);
+  if (chars.length <= cols) return s;
+  return chars.slice(0, Math.max(1, cols - 1)).join("") + "…";
+}
+
+// Columns a group of entries occupies, for the left-group cap below.
+function entriesWidth(entries: Entry[]): number {
+  return entries.reduce((n, e) => n + Array.from(e.text).length, 0);
+}
+
+// Inner width of a card at the dock's default width — an estimate (the
+// dock can be dragged), used only to cap the branch so it doesn't shove
+// the right-hand group off the row. The host does the exact alignment.
+function cardInnerColsEstimate(): number {
+  return Math.max(12, dockContentCols(dockDefaultWidth()) - 2);
+}
 
 // Card line 1 (the tree node's primary text): state glyph, optional
-// remote facet, the name (highlighted when active), then a dim project
-// tag. Distinct from the compact `sessionNodeEntry`, which trails the
-// branch on the single line instead of the project.
+// remote facet, the name (highlighted when active) and — for a remote
+// session — its backend target, with the git summary flush right.
+// Distinct from the compact `sessionNodeEntry`, which trails the git
+// summary on the single line it has.
 function sessionCardPrimary(id: number, activeId: number): TextPropertyEntry {
   const s = orchestratorSessions.get(id);
   if (!s) return styledRow([{ text: editor.t("pill.unknown") }]);
@@ -1394,61 +1446,87 @@ function sessionCardPrimary(id: number, activeId: number): TextPropertyEntry {
     text: s.label,
     style: { fg: isActive ? "ui.help_key_fg" : undefined, bold: true },
   });
-  const proj = editor.pathBasename(projectKeyOf(s));
-  segs.push({ text: "  " + PROJECT_ICON + " ", style: { fg: "ui.menu_disabled_fg" } });
-  segs.push({ text: proj, style: { fg: "ui.menu_disabled_fg", italic: true } });
   // A remote session surfaces its backend target (host / ns·pod) coloured
   // by the connection state — pill parity (the pill shows it at the right
-  // end of line 1). The discovered "· on-disk" tag is NOT repeated here:
-  // the card's third line (prLineEntries) already carries it, exactly like
-  // the pill.
+  // end of line 1).
   if (s.remote) {
     segs.push({
       text: "  " + s.remote.detail,
       style: { fg: remoteStateFg(s.remote.state), italic: true },
     });
   }
-  return styledRow(segs as Parameters<typeof styledRow>[0]);
+  // Right group. A being-created placeholder has no git summary; it gets
+  // the one-key affordance instead ("↵ Retry"), so the row below is free
+  // for the whole status message.
+  if (s.pending) {
+    return cardSplitRow(
+      segs,
+      pendingActionable(s.pending)
+        ? [{
+          text: "↵ " + editor.t("dock.ctx_retry"),
+          style: { fg: "ui.menu_disabled_fg", italic: true },
+        }]
+        : [],
+    );
+  }
+  return cardSplitRow(segs, gitLineParts(s).right);
 }
 
-// Card lines 2 & 3 (continuation rows). Line 2 is the branch + a
-// compact git summary, right-aligned as one group against the card's
-// right border; line 3 is the PR badge (or a blank spacer when there's
-// no PR, keeping every card the same height). Tree card rows are plain
-// text entries (no host flex spacer), so the line carries the
-// `align: "right"` entry property and the host's `render_tree_card` —
-// which knows the card's *actual* inner width, responsive or dragged —
-// pads it flush against the right border.
+// Card line 2 (the continuation row): what this workspace *is* on the
+// left — its branch when that says something the name doesn't, else the
+// project it belongs to — and its PR badge (or the on-disk tag) flush
+// right.
 function sessionCardExtraLines(id: number): TextPropertyEntry[] {
   const s = orchestratorSessions.get(id);
   if (!s) return [];
-  // A being-created placeholder shows its status in place of the git / PR
-  // lines: line 2 is the creating/connecting/error message, line 3 is a
-  // retry/resume hint (blank while still creating).
+  // A being-created placeholder spends the row on its status message
+  // (the retry affordance sits on line 1).
   if (s.pending) {
     const p = s.pending;
-    const actionable = pendingActionable(p);
     return [
-      styledRow([{ text: p.message, style: { fg: pendingMsgFg(p), italic: actionable } }]),
-      styledRow([
-        actionable
-          ? { text: pendingHintText(p), style: { fg: "ui.menu_disabled_fg", italic: true } }
-          : { text: " " },
-      ] as Parameters<typeof styledRow>[0]),
+      styledRow([{
+        text: p.message,
+        style: { fg: pendingMsgFg(p), italic: pendingActionable(p) },
+      }]),
     ];
   }
-  const git = gitLineParts(s);
-  const gitSegs: Entry[] = [...git.left];
-  if (git.right.length) {
-    gitSegs.push({ text: "   " });
-    gitSegs.push(...git.right);
-  }
-  const gitLine = styledRow(gitSegs as Parameters<typeof styledRow>[0]);
-  gitLine.properties = { align: "right" };
-  const pr = prLineEntries(s);
+  const dim = "ui.menu_disabled_fg";
+  const right = prLineEntries(s);
+  // The branch earns the row only when it differs from the workspace
+  // name — a worktree's branch is usually named after it, and printing
+  // it twice was pure noise. Otherwise the project takes the slot: it's
+  // the context the name doesn't carry. `(detached)` is reserved for a
+  // real repo with no branch; a plain directory just shows its project.
+  const branch = s.branch ||
+    (s.discovered
+      ? editor.t("pill.branch_worktree")
+      : s.git?.info
+      ? editor.t("pill.branch_detached")
+      : "");
+  const showBranch = branch !== "" && branch !== s.label;
+  const proj = editor.pathBasename(projectKeyOf(s));
+  const icon = showBranch ? BRANCH_ICON : PROJECT_ICON;
+  const text = showBranch ? branch : proj;
+  // Nothing to say that the name doesn't already say (a plain folder
+  // opened as its own project, whose label *is* the folder). The row
+  // stays empty rather than echoing the line above it.
+  if (text === s.label) {
+    return [cardSplitRow(right.length > 0 ? [] : [{ text: " " }], right)];
+  }
+  // Cap the branch/project so the badge keeps its columns: the host
+  // truncates the row's *end*, which is the badge. Budget = the card's
+  // inner width less this row's icon (2 cols), the badge, and the one
+  // column that always separates the two groups.
+  const cap = cardInnerColsEstimate() - 2 - entriesWidth(right) -
+    (right.length > 0 ? 1 : 0);
   return [
-    gitLine,
-    styledRow((pr.length ? pr : [{ text: " " }]) as Parameters<typeof styledRow>[0]),
+    cardSplitRow(
+      [
+        { text: icon + " ", style: { fg: dim } },
+        { text: capText(text, Math.max(8, cap)), style: { fg: dim, italic: !showBranch } },
+      ],
+      right,
+    ),
   ];
 }
 
@@ -2139,10 +2217,12 @@ const PROJECT_ICON = "▣";
 // already uses.
 const BRANCH_ICON = "▸";
 
-// Card line 2: branch (with icon, left) + a compact git summary
-// (right-aligned) that's useful even before any PR exists —
+// The modal pill's branch line: branch (with icon, left) + a compact
+// git summary (right-aligned) that's useful even before any PR exists —
 // ahead/behind the upstream and the uncommitted diffstat
-// (`+added −deleted`), or `clean`.
+// (`+added −deleted`), or `clean`. The dock card takes only the `right`
+// half — its name row carries the summary — so `left` (the branch) is
+// the pill's alone.
 function gitLineParts(s: AgentSession): { left: Entry[]; right: Entry[] } {
   const dim = "ui.menu_disabled_fg";
   let branch = s.branch || (s.discovered ? editor.t("pill.branch_worktree") : editor.t("pill.branch_detached"));
@@ -2272,7 +2352,10 @@ function stateGlyphEntry(s: AgentSession): Entry {
   return { text: sym.glyph + " ", style: { fg: sym.fg, bold: true } };
 }
 
-// Build one session row. Two densities, picked by `dockView`:
+// Build one session row for the modal picker's list. (The dock's own
+// tree rows are built by `sessionCardPrimary` / `sessionNodeEntry`; its
+// cards are two rows, not the three below.) Two densities, picked by
+// `dockView`:
 //
 //   card (default): a rounded `labeledSection` pill —
 //     line 1: <state> NAME (bold)              ▣ project

crates/fresh-editor/src/widgets/render.rs

@@ -4910,18 +4910,49 @@ fn render_tree_card(node: &TreeNode, item_height: u32, panel_width: u32) -> Rend
         // The pad is ASCII spaces (1 byte == 1 char each), so shifting
         // overlay offsets by the pad length is unit-correct for both
         // byte- and char-unit overlays.
-        let align_right = src
+        let align = src
             .properties
             .get("align")
             .and_then(|v| v.as_str())
-            .map(|v| v == "right")
-            .unwrap_or(false);
-        if align_right {
+            .unwrap_or("")
+            .to_string();
+        // `align: "between"` splits the row into a left group and a
+        // right one flush against the border — the card equivalent of
+        // the flex spacer a widget `Row` gets. The split point is a byte
+        // offset into the row's own text (`splitByte`), so the plugin
+        // says *where* the groups meet and the host, which alone knows
+        // the card's real width, decides how much space goes between
+        // them. Overflowing rows get a single separating space and fall
+        // through to the usual end-truncation.
+        let split = if align == "between" {
+            src.properties
+                .get("splitByte")
+                .and_then(|v| v.as_u64())
+                .map(|v| v as usize)
+                .filter(|&b| b <= src.text.len() && src.text.is_char_boundary(b))
+        } else {
+            None
+        };
+        // Where the padding goes: the row's start (right-aligned) or the
+        // group boundary (space-between).
+        let pad_at = match (align.as_str(), split) {
+            ("right", _) => Some(0),
+            ("between", Some(b)) => Some(b),
+            _ => None,
+        };
+        if let Some(at) = pad_at {
             let width = src.text.chars().count();
-            if width < inner_width {
-                let pad = " ".repeat(inner_width - width);
-                src.text.insert_str(0, &pad);
-                for o in src.inline_overlays.iter_mut() {
+            // A "between" row always keeps at least one space between
+            // the groups so they can't run together when the card is too
+            // narrow to hold both.
+            let pad_cols = inner_width.saturating_sub(width).max(usize::from(at > 0));
+            if pad_cols > 0 {
+                let pad = " ".repeat(pad_cols);
+                src.text.insert_str(at, &pad);
+                // The pad is ASCII spaces (1 byte == 1 char each), so
+                // shifting the overlays that sit after it is unit-correct
+                // for both byte- and char-unit overlays.
+                for o in src.inline_overlays.iter_mut().filter(|o| o.start >= at) {
                     o.start += pad.len();
                     o.end += pad.len();
                 }
@@ -7781,6 +7812,72 @@ mod tests {
         );
     }
 
+    /// One `align: "between"` card row: `left` and `right` groups meet
+    /// at `splitByte`, rendered in a card `width` columns wide.
+    fn between_card_row(left: &str, right: &str, width: u32) -> String {
+        let mut node = tnode("name", 0, false);
+        let mut line = TextPropertyEntry::text(format!("{left}{right}"));
+        line.properties.insert(
+            "align".to_string(),
+            serde_json::Value::String("between".to_string()),
+        );
+        line.properties.insert(
+            "splitByte".to_string(),
+            serde_json::Value::Number((left.len() as u64).into()),
+        );
+        node.extra_lines = vec![line];
+        let spec = WidgetSpec::Tree {
+            nodes: vec![node],
+            item_keys: vec!["x".to_string()],
+            selected_index: -1,
+            visible_rows: 10,
+            expanded_keys: vec![],
+            checkable: false,
+            item_height: 2,
+            card_borders: true,
+            key: Some("T".to_string()),
+        };
+        let out = render_spec(&spec, &HashMap::new(), "", width);
+        // Top border, name row, the split row, bottom border.
+        out.entries[2].text.trim_end_matches('\n').to_string()
+    }
+
+    /// A card row (the orchestrator dock's workspace cards) can ask for
+    /// its right-hand group to sit flush against the card border while
+    /// the left group starts at the left one — `align: "between"` with
+    /// the group boundary as a byte offset. Only the host knows the
+    /// card's real width (the dock is resizable), so it owns the gap.
+    #[test]
+    fn tree_card_between_alignment_pushes_the_right_group_to_the_border() {
+        let row = between_card_row("branch", "PR #7", 30);
+        assert!(
+            row.starts_with("│branch") && row.ends_with("PR #7│"),
+            "left group hugs the left border and the right group the right one, got {row:?}"
+        );
+        // Padding only between them — not a plugin-side guess that
+        // leaves both groups floating mid-card.
+        let inner = row.trim_start_matches('│').trim_end_matches('│');
+        assert!(
+            inner["branch".len()..inner.len() - "PR #7".len()]
+                .chars()
+                .all(|c| c == ' '),
+            "the two groups are separated by padding only, got {inner:?}"
+        );
+    }
+
+    /// The groups still get a separating space when the card has no room
+    /// to spare — they must never run together into one unreadable word,
+    /// even at the exact width where they would just barely both fit.
+    #[test]
+    fn tree_card_between_alignment_keeps_a_gap_when_the_row_is_full() {
+        // Inner width 15 = exactly "abcdefghij" + "PR #7".
+        let row = between_card_row("abcdefghij", "PR #7", 17);
+        assert!(
+            !row.contains("ijPR"),
+            "a full row still separates the groups, got {row:?}"
+        );
+    }
+
     #[test]
     fn tree_renders_only_top_level_when_nothing_expanded() {
         let spec = make_tree(