feat(maestro): make TUI session cards two lines

Closes #118

crates/maestro-cli/src/sessions.rs

@@ -3,6 +3,7 @@
 use std::collections::HashMap;
 use std::io::Write;
 
+use maestro_protocol::display::abbreviate_dir;
 use maestro_protocol::{
     ActivityState, ClientError, CreateSessionRequest, DaemonClient, DaemonInfo, Session,
     SessionStatus, WorktreeSpec,
@@ -138,21 +139,6 @@ pub(crate) fn blocked_label(s: &Session) -> String {
         .unwrap_or_default()
 }
 
-/// Render a path with the daemon's home dir collapsed to `~`. Mirrors the web
-/// UI's abbreviation so CLI and browser show the same directory shorthand.
-pub(crate) fn abbreviate_dir(path: &std::path::Path, home: &str) -> String {
-    let p = path.to_string_lossy();
-    if !home.is_empty() {
-        if p == home {
-            return "~".into();
-        }
-        if let Some(rest) = p.strip_prefix(&format!("{home}/")) {
-            return format!("~/{rest}");
-        }
-    }
-    p.into_owned()
-}
-
 #[cfg(test)]
 mod tests {
     use std::collections::HashMap;

crates/maestro-cli/src/worktrees.rs

@@ -6,10 +6,10 @@
 
 use std::io::Write;
 
+use maestro_protocol::display::abbreviate_dir;
 use maestro_protocol::{ClientError, DaemonClient, DaemonInfo, InTheWay, RetainedWorktree};
 
 use crate::cli::{ListWorktreesArgs, ReclaimArgs};
-use crate::sessions::abbreviate_dir;
 
 /// `maestro worktrees list`
 pub async fn run_list(

crates/maestro-protocol/src/display.rs

@@ -0,0 +1,321 @@
+//! Path-abbreviation helpers shared by every client that renders a session's
+//! directory (CLI, TUI, web (#117)). Ports of `web/src/types.ts` and
+//! `web/src/tree.ts`'s `abbreviateCwd`, `abbreviateFolderName`, `mergeLinear`,
+//! and `sessionTreePath` — keep them in sync.
+
+use std::path::{Path, PathBuf};
+
+use crate::Session;
+
+/// Collapse a daemon's home dir to `~`. `home` empty leaves the path
+/// untouched. Mirrors the web's `abbreviateCwd`.
+pub fn abbreviate_dir(path: &Path, home: &str) -> String {
+    let p = path.to_string_lossy();
+    if !home.is_empty() {
+        if p == home {
+            return "~".into();
+        }
+        if let Some(rest) = p.strip_prefix(&format!("{home}/")) {
+            return format!("~/{rest}");
+        }
+    }
+    p.into_owned()
+}
+
+/// Result of [`abbreviate_folder_name`]: the last path segment kept verbatim,
+/// and — when there was something to collapse — the shortened lead-in a
+/// caller can render dimmed (the web's `.folder-stem`).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AbbreviatedFolderName {
+    /// The collapsed earlier segments, joined by `/`, with no trailing
+    /// slash. `None` when `name` had two or fewer segments — nothing to
+    /// gain from collapsing, so `last` carries the name unabbreviated.
+    pub stem: Option<String>,
+    pub last: String,
+}
+
+/// `~/git.naps.pt/naps62/maestro` → stem `~/g/n`, last `maestro`: keep the
+/// last segment verbatim, collapse every earlier one to its first character.
+/// Two-or-fewer segments are left alone. Mirrors the web's
+/// `abbreviateFolderName`, minus the HTML escaping/wrapping — a ratatui
+/// caller styles `stem` dim itself rather than parsing markup out of it.
+pub fn abbreviate_folder_name(name: &str) -> AbbreviatedFolderName {
+    let parts: Vec<&str> = name.split('/').collect();
+    if parts.len() <= 2 {
+        return AbbreviatedFolderName {
+            stem: None,
+            last: name.to_string(),
+        };
+    }
+    let last = parts[parts.len() - 1].to_string();
+    let stem = parts[..parts.len() - 1]
+        .iter()
+        .map(|p| {
+            if *p == "~" {
+                "~".to_string()
+            } else {
+                p.chars().next().map(String::from).unwrap_or_default()
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("/");
+    AbbreviatedFolderName {
+        stem: Some(stem),
+        last,
+    }
+}
+
+/// The directory a session lives in: its live `current_cwd` if the daemon
+/// has observed one, else the spawn `cwd`. Mirrors the web's `sessionCwd`.
+fn session_cwd(s: &Session) -> Option<PathBuf> {
+    if let Some(cur) = &s.current_cwd {
+        if !cur.as_os_str().is_empty() {
+            return Some(cur.clone());
+        }
+    }
+    if !s.cwd.as_os_str().is_empty() {
+        return Some(s.cwd.clone());
+    }
+    None
+}
+
+/// Where a session sits in the directory tree. A worktree session belongs to
+/// its repository, not to the worktree (#99): otherwise `~/tea/agent-skills`
+/// grows a `~/tea/agent-skills/worktrees/largo-clarinet` folder holding one
+/// session of the same name, and the repository stops being where you look
+/// for the work. Mirrors the web's `sessionTreePath`.
+pub fn session_tree_path(s: &Session) -> Option<PathBuf> {
+    if let Some(wt) = &s.worktree {
+        return Some(wt.base_repo.clone());
+    }
+    session_cwd(s)
+}
+
+/// One node of a directory tree grouping sessions by path, generic over the
+/// leaf payload since building the tree itself (grouping key, sort order,
+/// filtering) is not this crate's job — only [`merge_linear`] is.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TreeNode<T> {
+    Folder(TreeFolder<T>),
+    Leaf(T),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TreeFolder<T> {
+    pub name: String,
+    pub path: String,
+    pub children: Vec<TreeNode<T>>,
+}
+
+/// Fold a folder with a single folder-child into one node (`a` + `b` →
+/// `a/b`), repeating down the chain, then recurse into the surviving
+/// branches. The merged node keeps the deepest path so collapse/expand state
+/// stays stable as it grows. Mirrors the web's `mergeLinear`.
+pub fn merge_linear<T>(folder: TreeFolder<T>) -> TreeFolder<T> {
+    let mut cur = folder;
+    loop {
+        let single_folder_child =
+            cur.children.len() == 1 && matches!(cur.children[0], TreeNode::Folder(_));
+        if !single_folder_child {
+            break;
+        }
+        let child = match cur.children.pop().expect("checked len == 1 above") {
+            TreeNode::Folder(f) => f,
+            TreeNode::Leaf(_) => unreachable!("checked matches! above"),
+        };
+        cur = TreeFolder {
+            name: format!("{}/{}", cur.name, child.name),
+            path: child.path,
+            children: child.children,
+        };
+    }
+    cur.children = cur
+        .children
+        .into_iter()
+        .map(|c| match c {
+            TreeNode::Folder(f) => TreeNode::Folder(merge_linear(f)),
+            leaf => leaf,
+        })
+        .collect();
+    cur
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{SessionStatus, SessionWorktree};
+    use chrono::{TimeZone, Utc};
+    use std::collections::HashMap;
+    use uuid::Uuid;
+
+    fn session(cwd: &str) -> Session {
+        Session {
+            id: Uuid::from_u128(1),
+            cwd: PathBuf::from(cwd),
+            command: "bash".into(),
+            env: HashMap::new(),
+            metadata: HashMap::new(),
+            worktree: None,
+            status: SessionStatus::Running,
+            created_at: Utc.with_ymd_and_hms(2026, 8, 25, 12, 0, 0).unwrap(),
+            foreground: None,
+            activity: Default::default(),
+            activity_detail: None,
+            last_activity_at: Utc::now(),
+            activity_since: Utc::now(),
+            current_cwd: None,
+            blocked_work: None,
+        }
+    }
+
+    #[test]
+    fn abbreviate_dir_collapses_home() {
+        assert_eq!(
+            abbreviate_dir(Path::new("/home/naps/maestro"), "/home/naps"),
+            "~/maestro"
+        );
+        assert_eq!(abbreviate_dir(Path::new("/home/naps"), "/home/naps"), "~");
+    }
+
+    #[test]
+    fn abbreviate_dir_leaves_paths_outside_home_untouched() {
+        assert_eq!(
+            abbreviate_dir(Path::new("/srv/work/api"), "/home/naps"),
+            "/srv/work/api"
+        );
+        assert_eq!(
+            abbreviate_dir(Path::new("/srv/work/api"), ""),
+            "/srv/work/api"
+        );
+    }
+
+    #[test]
+    fn abbreviate_folder_name_collapses_the_stem() {
+        let got = abbreviate_folder_name("~/git.naps.pt/naps62/maestro");
+        assert_eq!(
+            got,
+            AbbreviatedFolderName {
+                stem: Some("~/g/n".into()),
+                last: "maestro".into(),
+            }
+        );
+    }
+
+    /// Two-or-fewer segments are left alone — nothing to gain from collapsing.
+    #[test]
+    fn abbreviate_folder_name_two_segment_no_op() {
+        assert_eq!(
+            abbreviate_folder_name("~/work"),
+            AbbreviatedFolderName {
+                stem: None,
+                last: "~/work".into(),
+            }
+        );
+        assert_eq!(
+            abbreviate_folder_name("work"),
+            AbbreviatedFolderName {
+                stem: None,
+                last: "work".into(),
+            }
+        );
+    }
+
+    #[test]
+    fn session_tree_path_prefers_worktree_base_repo() {
+        let mut s = session("/home/n/tea/agent-skills/worktrees/largo-clarinet");
+        s.worktree = Some(SessionWorktree {
+            path: PathBuf::from("/home/n/tea/agent-skills/worktrees/largo-clarinet"),
+            base_repo: PathBuf::from("/home/n/tea/agent-skills"),
+        });
+        assert_eq!(
+            session_tree_path(&s),
+            Some(PathBuf::from("/home/n/tea/agent-skills"))
+        );
+    }
+
+    #[test]
+    fn session_tree_path_falls_back_to_cwd_without_a_worktree() {
+        let s = session("/home/n/tea/arr");
+        assert_eq!(
+            session_tree_path(&s),
+            Some(PathBuf::from("/home/n/tea/arr"))
+        );
+    }
+
+    #[test]
+    fn session_tree_path_prefers_live_current_cwd_over_spawn_cwd() {
+        let mut s = session("/home/n/tea/arr");
+        s.current_cwd = Some(PathBuf::from("/home/n/tea/arr/crates"));
+        assert_eq!(
+            session_tree_path(&s),
+            Some(PathBuf::from("/home/n/tea/arr/crates"))
+        );
+    }
+
+    fn leaf(name: &str) -> TreeNode<String> {
+        TreeNode::Leaf(name.into())
+    }
+
+    fn folder(name: &str, path: &str, children: Vec<TreeNode<String>>) -> TreeFolder<String> {
+        TreeFolder {
+            name: name.into(),
+            path: path.into(),
+            children,
+        }
+    }
+
+    /// The web's mergeLinear test: keeps the deepest path so collapse state
+    /// survives growth.
+    #[test]
+    fn merge_linear_folds_a_chain_and_keeps_the_deepest_path() {
+        let tree = folder("a", "a", vec![TreeNode::Folder(folder("b", "a/b", vec![]))]);
+        let merged = merge_linear(tree);
+        assert_eq!(merged.name, "a/b");
+        assert_eq!(merged.path, "a/b");
+    }
+
+    #[test]
+    fn merge_linear_stops_where_a_directory_branches() {
+        let tree = folder(
+            "git",
+            "git",
+            vec![
+                TreeNode::Folder(folder("one", "git/one", vec![])),
+                TreeNode::Folder(folder("two", "git/two", vec![])),
+            ],
+        );
+        let merged = merge_linear(tree);
+        assert_eq!(merged.name, "git");
+        assert_eq!(merged.children.len(), 2);
+    }
+
+    #[test]
+    fn merge_linear_stops_at_a_leaf() {
+        let tree = folder("a", "a", vec![leaf("session")]);
+        let merged = merge_linear(tree);
+        assert_eq!(merged.name, "a");
+        assert_eq!(merged.children, vec![leaf("session")]);
+    }
+
+    #[test]
+    fn merge_linear_recurses_into_surviving_branches() {
+        let tree = folder(
+            "root",
+            "root",
+            vec![
+                TreeNode::Folder(folder(
+                    "a",
+                    "root/a",
+                    vec![TreeNode::Folder(folder("b", "root/a/b", vec![leaf("s")]))],
+                )),
+                leaf("other"),
+            ],
+        );
+        let merged = merge_linear(tree);
+        assert_eq!(merged.children.len(), 2);
+        let TreeNode::Folder(nested) = &merged.children[0] else {
+            panic!("expected folder")
+        };
+        assert_eq!(nested.name, "a/b");
+    }
+}

crates/maestro-protocol/src/lib.rs

@@ -9,6 +9,7 @@
 
 #[cfg(feature = "client")]
 pub mod client;
+pub mod display;
 pub mod routes;
 
 #[cfg(feature = "client")]

crates/maestro-tui/src/palette.rs

@@ -106,6 +106,10 @@ pub struct Palette {
     pub card: Surface,
     /// The surface the highlighted card swaps in.
     pub selection: Surface,
+    /// Background for TUI-owned chrome outside cards. Fixed-RGB chrome must
+    /// paint this background too; otherwise its contrast depends on the
+    /// operator's terminal theme.
+    pub chrome_bg: Color,
     /// Panel border while that panel holds focus.
     pub border_focused: Color,
     /// Panel border while it does not.
@@ -148,8 +152,9 @@ impl Palette {
             awaiting: Color::Rgb(0xf2, 0xcc, 0x60),
             error: Color::Rgb(0xff, 0x94, 0x92),
         },
+        chrome_bg: Color::Rgb(0x14, 0x16, 0x1b),
         border_focused: Color::Rgb(0x58, 0xa6, 0xff),
-        border_unfocused: Color::Rgb(0x30, 0x36, 0x3d),
+        border_unfocused: Color::Rgb(0x6b, 0x72, 0x80),
         focus_accent: Color::Rgb(0x58, 0xa6, 0xff),
         group_row: Color::Rgb(0x8f, 0xa3, 0xc8),
         mode_normal_bg: Color::Rgb(0x58, 0xa6, 0xff),
@@ -172,15 +177,18 @@ impl Palette {
     /// Border style for a panel, by whether it holds focus.
     pub fn border_style(&self, focused: bool) -> Style {
         if focused {
-            Style::default().fg(self.border_focused)
+            Style::default().bg(self.chrome_bg).fg(self.border_focused)
         } else {
-            Style::default().fg(self.border_unfocused)
+            Style::default()
+                .bg(self.chrome_bg)
+                .fg(self.border_unfocused)
         }
     }
 
     /// Style for a sidebar group heading.
     pub fn group_row_style(&self) -> Style {
         Style::default()
+            .bg(self.chrome_bg)
             .fg(self.group_row)
             .add_modifier(Modifier::BOLD)
     }
@@ -200,7 +208,7 @@ impl Palette {
 
     /// Style for error text outside a card.
     pub fn error_style(&self) -> Style {
-        Style::default().fg(self.error_text)
+        Style::default().bg(self.chrome_bg).fg(self.error_text)
     }
 }
 
@@ -298,10 +306,13 @@ mod tests {
     }
 
     /// Other panels' roles are RGB too, so a preset swap moves all of them.
+    /// Foregrounds are checked against the chrome background they are
+    /// actually painted on; they must never rely on the terminal default.
     #[test]
     fn chrome_roles_are_rgb_values() {
         let p = active();
         for (name, color) in [
+            ("chrome_bg", p.chrome_bg),
             ("border_focused", p.border_focused),
             ("border_unfocused", p.border_unfocused),
             ("focus_accent", p.focus_accent),
@@ -325,6 +336,19 @@ mod tests {
             let ratio = contrast_ratio(fg, bg).unwrap();
             assert!(ratio >= 4.5, "mode {name} contrast {ratio:.2} is below 4.5");
         }
+        for (name, fg, floor) in [
+            ("border_focused", p.border_focused, 3.0),
+            ("border_unfocused", p.border_unfocused, 3.0),
+            ("focus_accent", p.focus_accent, 3.0),
+            ("group_row", p.group_row, 4.5),
+            ("error_text", p.error_text, 4.5),
+        ] {
+            let ratio = contrast_ratio(fg, p.chrome_bg).unwrap();
+            assert!(
+                ratio >= floor,
+                "{name} contrast {ratio:.2} is below {floor} on chrome_bg"
+            );
+        }
     }
 
     #[test]

crates/maestro-tui/src/sidebar.rs

@@ -2,8 +2,7 @@
 //!
 //! Line 1: status glyph (● attached / ○ live / ✗ dead) + name.
 //! Line 2: activity dot + duration in the state's colour, plus the
-//! blocked-work and exited fragments when they apply. Absent entirely when
-//! it has nothing to say.
+//! adaptive detail, blocked-work, exited, and command fragments.
 
 use std::collections::HashSet;
 
@@ -18,8 +17,8 @@ use uuid::Uuid;
 
 use crate::palette;
 
-/// Time-in-state alone earns a meta line only once the session has sat in
-/// its current activity state this long (docs/SIDEBAR.md).
+/// Time-in-state earns a duration fragment once the session has sat in its
+/// current activity state this long (docs/SIDEBAR.md).
 const META_LINE_AFTER_SECS: i64 = 30;
 /// A payload predating #102 defaults `activity_since` to the Unix epoch. Per
 /// docs/SIDEBAR.md such a session contributes no duration — the dot still
@@ -74,9 +73,8 @@ impl Sidebar {
             let highlighted = self.highlight == Some(s.id);
             let base = card_base(highlighted);
             lines.push(Line::from(self.name_row(s, width)));
-            if let Some(meta) = self.meta_row(s, width) {
-                lines.push(Line::from(pad_to_width(meta, width, base)));
-            }
+            let meta = self.meta_row(s, width);
+            lines.push(Line::from(pad_to_width(meta, width, base)));
         }
         f.render_widget(Paragraph::new(lines), inner);
     }
@@ -123,8 +121,8 @@ impl Sidebar {
         spans
     }
 
-    /// The adaptive second line: `<dot> <duration> [<blocked work> | exited]`.
-    fn meta_row(&self, s: &Session, width: usize) -> Option<Vec<Span<'static>>> {
+    /// The adaptive second line: `<dot> [<duration>] [<detail>] [<blocked work> | exited] <command>`.
+    fn meta_row(&self, s: &Session, width: usize) -> Vec<Span<'static>> {
         let now = Utc::now();
         let held = held_for(s, now);
         let held_secs = held.map(|d| d.num_seconds()).unwrap_or(0);
@@ -132,14 +130,6 @@ impl Sidebar {
         // on line 1; the kill confirm names the specifics.
         let blocked = s.blocked_work.filter(|b| !b.is_clear());
         let dead = s.status == SessionStatus::Dead;
-        let errored = s.activity == ActivityState::Error;
-        if (held.is_none() || held_secs < META_LINE_AFTER_SECS)
-            && blocked.is_none()
-            && !dead
-            && !errored
-        {
-            return None;
-        }
         let highlighted = self.highlight == Some(s.id);
         let base = card_base(highlighted);
         let dot_style = base.patch(Style::default().fg(activity_color(s.activity, highlighted)));
@@ -148,13 +138,10 @@ impl Sidebar {
             Span::styled(META_INDENT, base),
             Span::styled("●", dot_style),
         ];
-        if let Some(d) = held {
+        if let Some(d) = held.filter(|_| held_secs >= META_LINE_AFTER_SECS) {
             spans.push(Span::styled(" ", base));
             spans.push(Span::styled(format_state_duration(d), dot_style));
         }
-        // The trailing fragments are measured up front so a long detail
-        // truncates ahead of them instead of pushing them off the line
-        // (docs/SIDEBAR.md).
         let mut tail: Vec<Span<'static>> = Vec::new();
         if let Some(b) = blocked {
             tail.push(Span::styled(format!(" ⚠ {b}"), muted));
@@ -162,9 +149,19 @@ impl Sidebar {
         if dead {
             tail.push(Span::styled(" exited", muted));
         }
+        let command = Span::styled(format!(" {}", s.command), muted);
+
+        // Reserve the trailing fragments so detail truncates before them;
+        // the command is itself the final truncation target on narrow cards.
+        let head_w: usize = spans.iter().map(|sp| sp.width()).sum();
+        let tail_w: usize = tail.iter().map(|sp| sp.width()).sum();
+        let command_w = command.width();
+        let available = width.saturating_sub(head_w);
+        if tail_w + command_w > available {
+            spans.extend(fit_to_width(vec![command], available));
+            return spans;
+        }
         if let Some(detail) = s.activity_detail.as_deref().filter(|d| !d.is_empty()) {
-            let head_w: usize = spans.iter().map(|sp| sp.width()).sum();
-            let tail_w: usize = tail.iter().map(|sp| sp.width()).sum();
             let budget = width.saturating_sub(head_w + tail_w);
             spans.extend(fit_to_width(
                 vec![Span::styled(format!(" {detail}"), muted)],
@@ -172,7 +169,8 @@ impl Sidebar {
             ));
         }
         spans.extend(tail);
-        Some(fit_to_width(spans, width))
+        spans.push(command);
+        fit_to_width(spans, width)
     }
 }
 
@@ -406,10 +404,10 @@ mod tests {
         }
     }
 
-    /// A freshly-active session stays one line — never an empty placeholder
-    /// row (docs/SIDEBAR.md).
+    /// A fresh session still gets its unconditional second line, but no
+    /// duration until it has been held in state for 30 seconds.
     #[test]
-    fn freshly_active_session_stays_one_line() {
+    fn fresh_session_renders_two_lines_without_duration() {
         let mut s = session_named(1, "claude");
         s.activity_since = Utc::now() - Duration::seconds(10);
         let sb = Sidebar {
@@ -421,8 +419,18 @@ mod tests {
         assert_eq!(content(&all[0]), "sessions");
         assert!(row_containing(&all, "claude").contains('○'));
         assert!(
-            content(&all[2]).is_empty(),
-            "line 2 must be absent, got {:?}",
+            all[2].contains('●'),
+            "line 2 must carry the dot: {:?}",
+            all[2]
+        );
+        assert!(
+            all[2].contains("bash"),
+            "line 2 must carry the command: {:?}",
+            all[2]
+        );
+        assert!(
+            !all[2].contains("10s"),
+            "fresh cards have no duration: {:?}",
             all[2]
         );
     }
@@ -553,11 +561,12 @@ mod tests {
         );
     }
 
-    /// The sidebar is narrow: the meta line truncates with `…` and never
-    /// wraps onto a third row (docs/SIDEBAR.md).
+    /// The sidebar is narrow: the command truncates with `…` and never wraps
+    /// onto a third row (docs/SIDEBAR.md).
     #[test]
-    fn meta_line_truncates_instead_of_wrapping() {
+    fn meta_line_command_truncates_instead_of_wrapping() {
         let mut s = session_named(1, "claude");
+        s.command = "a command that cannot fit".into();
         s.activity_since = Utc::now() - Duration::seconds(5);
         s.blocked_work = Some(InTheWay {
             uncommitted_files: 120,
@@ -573,7 +582,7 @@ mod tests {
         let meta = content(&all[idx + 1]);
         assert!(
             meta.trim_end().ends_with('…'),
-            "truncated meta line must end with …: {meta:?}"
+            "truncated command must end with …: {meta:?}"
         );
         assert!(
             content(&all[idx + 2]).trim().is_empty(),
@@ -688,10 +697,6 @@ mod tests {
             rendered.contains("exited"),
             "dead session must still show line 2:\n{rendered}"
         );
-        assert!(
-            !rendered.contains('h') || !rendered.contains("● "),
-            "no duration may follow the dot for an epoch stamp:\n{rendered}"
-        );
         for line in rendered.lines().filter(|l| l.contains('●')) {
             assert!(
                 !line
@@ -736,6 +741,48 @@ mod tests {
         );
     }
 
+    #[test]
+    fn command_renders_on_line_two_even_when_name_is_metadata() {
+        let s = session_named(1, "friendly name");
+        let sb = Sidebar {
+            sessions: vec![s],
+            highlight: None,
+            attached: Default::default(),
+        };
+        let all = rows(&draw(&sb, 40, 6));
+        assert!(
+            all[1].contains("friendly name"),
+            "name must stay on line 1: {:?}",
+            all[1]
+        );
+        assert!(
+            all[2].contains("bash"),
+            "command must be on line 2: {:?}",
+            all[2]
+        );
+    }
+
+    #[test]
+    fn narrow_meta_line_keeps_dot_and_truncates_command() {
+        let s = session_named(1, "name");
+        let sb = Sidebar {
+            sessions: vec![s],
+            highlight: None,
+            attached: Default::default(),
+        };
+        let all = rows(&draw(&sb, 10, 6));
+        assert!(
+            all[2].contains('●'),
+            "dot must survive narrow cards: {:?}",
+            all[2]
+        );
+        assert!(
+            all[2].contains('…'),
+            "command should truncate: {:?}",
+            all[2]
+        );
+    }
+
     /// Reversed video makes a card unreadable against a background; cards
     /// use explicit backgrounds instead (docs/SIDEBAR.md, #108).
     #[test]
@@ -775,7 +822,7 @@ mod tests {
         let buf = draw(&sb, 28, 8);
         let all = rows(&buf);
         let claude_y = all.iter().position(|l| l.contains("claude")).unwrap();
-        let bash_y = all.iter().position(|l| l.contains("bash")).unwrap();
+        let bash_y = all.iter().position(|l| l.contains("○ bash")).unwrap();
 
         let p = palette::active();
         assert_eq!(

crates/maestro/src/main.rs

@@ -19,8 +19,7 @@ use tracing_subscriber::EnvFilter;
 #[command(
     name = "maestro",
     version,
-    about = "Unified CLI / daemon / TUI for the Maestro terminal-session orchestrator",
-    arg_required_else_help = true
+    about = "Unified CLI / daemon / TUI for the Maestro terminal-session orchestrator"
 )]
 struct Cli {
     /// Override the daemon HTTP base clients talk to (e.g.
@@ -37,8 +36,11 @@ struct Cli {
     #[arg(short, long, global = true, action = clap::ArgAction::Count)]
     verbose: u8,
 
+    /// A missing subcommand defaults to the TUI (#119): a bare `maestro` opens
+    /// the terminal UI. Builds without the `tui` feature have no UI surface,
+    /// so they print help and exit 0 instead.
     #[command(subcommand)]
-    command: Command,
+    command: Option<Command>,
 }
 
 #[derive(Debug, Subcommand)]
@@ -89,7 +91,22 @@ fn main() -> ExitCode {
 }
 
 async fn dispatch(cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
-    match cli.command {
+    let command = match cli.command {
+        Some(command) => command,
+        None => {
+            #[cfg(feature = "tui")]
+            {
+                Command::Tui(maestro_tui::cli::TuiArgs { daemon_url: None })
+            }
+            #[cfg(not(feature = "tui"))]
+            {
+                use clap::CommandFactory;
+                let _ = <Cli as CommandFactory>::command().print_help();
+                return Ok(());
+            }
+        }
+    };
+    match command {
         #[cfg(feature = "cli")]
         Command::List(args) => {
             maestro_cli::dispatch(
@@ -166,19 +183,19 @@ fn init_tracing(cli: &Cli) {
 }
 
 #[cfg(feature = "cli")]
-fn is_cli_subcommand(command: &Command) -> bool {
+fn is_cli_subcommand(command: &Option<Command>) -> bool {
     matches!(
         command,
-        Command::List(_)
-            | Command::Spawn(_)
-            | Command::Attach(_)
-            | Command::Kill(_)
-            | Command::Hooks(_)
+        Some(Command::List(_))
+            | Some(Command::Spawn(_))
+            | Some(Command::Attach(_))
+            | Some(Command::Kill(_))
+            | Some(Command::Hooks(_))
     )
 }
 
 #[cfg(not(feature = "cli"))]
-fn is_cli_subcommand(_command: &Command) -> bool {
+fn is_cli_subcommand(_command: &Option<Command>) -> bool {
     false
 }
 
@@ -216,12 +233,20 @@ mod tests {
     }
 
     /// Parse argv the way `main` does, returning just the dispatched subcommand.
-    fn command_of(argv: &[&str]) -> Command {
+    fn command_of(argv: &[&str]) -> Option<Command> {
         Cli::try_parse_from(argv)
             .unwrap_or_else(|e| panic!("parse {argv:?}: {e}"))
             .command
     }
 
+    #[test]
+    fn bare_invocation_parses_to_no_subcommand() {
+        // The TUI-vs-help default is applied in `dispatch`; parsing must not
+        // reject an empty argv.
+        assert!(command_of(&["maestro"]).is_none());
+        assert!(command_of(&["maestro", "--verbose"]).is_none());
+    }
+
     #[cfg(feature = "cli")]
     #[test]
     fn cli_subcommands_are_classified_as_cli() {

crates/maestro/tests/cli.rs

@@ -54,11 +54,35 @@ fn version_flag_succeeds() {
     assert!(text.contains("maestro"), "--version output: {text}");
 }
 
+/// A bare `maestro` must never fall back to help on a build that has a TUI:
+/// the missing subcommand defaults to `tui` (#119). Point at a port with
+/// nothing listening so the TUI's health probe fails fast instead of blocking
+/// on a terminal.
+#[cfg(feature = "tui")]
 #[test]
-fn no_args_prints_help_and_fails() {
-    // `arg_required_else_help = true` => exit non-zero but show usage.
+fn bare_invocation_dispatches_to_the_tui() {
+    let (ok, text) = run(&["--daemon-url", "http://127.0.0.1:9"]);
+    assert!(
+        !ok,
+        "TUI against a dead daemon should exit non-zero:\n{text}"
+    );
+    assert!(
+        text.contains("daemon unreachable"),
+        "bare invocation should have run the TUI's daemon probe:\n{text}"
+    );
+    assert!(
+        !text.contains("Usage"),
+        "bare invocation must not print help when a TUI exists:\n{text}"
+    );
+}
+
+/// Builds without the `tui` feature keep the historical behaviour: no args =>
+/// help, exit 0 (#119).
+#[cfg(not(feature = "tui"))]
+#[test]
+fn bare_invocation_prints_help_and_exits_zero() {
     let (ok, text) = run(&[]);
-    assert!(!ok, "bare invocation should fail:\n{text}");
+    assert!(ok, "bare invocation should exit 0:\n{text}");
     assert!(text.contains("Usage"), "expected usage text:\n{text}");
 }
 

docs/INSTALL.md

@@ -119,6 +119,9 @@ The wizard always installs the default-feature build.
 
 `maestro tui` is the keyboard-and-mouse driven terminal UI client. It ships
 in the default feature set, so a vanilla `cargo install maestro` builds it.
+A bare `maestro` opens the TUI too — the missing subcommand defaults to `tui`
+(#119), so `maestro --daemon-url http://host:7070` works as well. Builds
+without the `tui` feature have no UI to open and print help instead (exit 0).
 Drop the `tui` feature to skip it on hosts that don't need the UI surface
 (`--no-default-features --features cli,daemon`).