feat(maestro): TUI spawn form stops naming sessions

The name field starts empty behind a hint, ^R reroll is gone, and the
fetched handle seeds the worktree branch instead. Fast-forward spawns with
no name at all. A card whose name the daemon generated renders muted.

Refs #131
This commit is contained in:
Miguel Palhas
2026-09-02 18:05:05 +01:00
parent 6173c86694
commit bd252fc954
4 changed files with 202 additions and 181 deletions
+13 -33
View File
@@ -112,8 +112,6 @@ pub enum Effect {
/// Fast-forward spawn (#67): resolve every default from the daemon and
/// spawn with no form; unresolvable defaults open a pre-filled form.
FastForward,
/// A reroll drained the form's local name batch (#64).
RefillNames,
/// The form's target changed: probe `/api/gitroot` so the worktree
/// section knows its base repo (#65). `seq` guards stale answers.
ProbeGitRoot {
@@ -301,7 +299,6 @@ impl App {
Effect::Kill(id) => self.submit_kill(id).await,
Effect::LoadDraft => self.spawn_load_draft(),
Effect::FastForward => self.spawn_fast_forward(),
Effect::RefillNames => self.spawn_refill_names(),
Effect::ProbeGitRoot { seq, path } => self.spawn_probe_git_root(seq, path),
Effect::LoadBranches => self.spawn_load_branches(),
Effect::Rename { id, name } => self.submit_rename(id, &name).await,
@@ -649,9 +646,6 @@ impl App {
Err(e) => draft.error = Some(e.to_string()),
}
}
if draft.take_name_refill() {
effects.push(Effect::RefillNames);
}
if let Some((seq, path)) = draft.take_gitroot_probe(std::time::Instant::now()) {
effects.push(Effect::ProbeGitRoot { seq, path });
}
@@ -696,17 +690,6 @@ impl App {
});
}
fn spawn_refill_names(&self) {
let Some(draft) = self.draft_id() else {
return;
};
let (_, http, base, tx) = self.loader_handles();
tokio::spawn(async move {
let names = fetch_names(&http, &base, crate::draft::NAME_BATCH_SIZE).await;
let _ = tx.send(DraftUpdate::Names { draft, names });
});
}
fn spawn_probe_git_root(&self, seq: u32, path: PathBuf) {
let Some(draft) = self.draft_id() else {
return;
@@ -774,7 +757,6 @@ impl App {
}
let want = match &update {
DraftUpdate::Data { draft, .. }
| DraftUpdate::Names { draft, .. }
| DraftUpdate::GitRoot { draft, .. }
| DraftUpdate::Branches { draft, .. } => *draft,
// Handled above; it targets no particular draft.
@@ -806,11 +788,6 @@ impl App {
draft.seed_names(names);
}
}
DraftUpdate::Names { names, .. } => {
if !names.is_empty() {
draft.extend_names(names);
}
}
DraftUpdate::GitRoot { seq, root, .. } => {
draft.resolve_gitroot(seq, root);
follow_up_branches = draft.take_branch_load().is_some();
@@ -1147,10 +1124,6 @@ enum DraftUpdate {
projects: Option<Vec<maestro_protocol::Project>>,
names: Vec<String>,
},
Names {
draft: u64,
names: Vec<String>,
},
GitRoot {
draft: u64,
seq: u32,
@@ -1639,7 +1612,8 @@ mod tests {
let req = &posts[0];
assert_eq!(req["cwd"], json!("/repos/fresh"));
assert_eq!(req["command"], json!("aider"));
assert_eq!(req["metadata"]["name"], json!("crimson-otter"));
// #131: the fast path names no session; the daemon does.
assert_eq!(req["metadata"], json!({}));
assert_eq!(req["worktree"]["base_repo"], json!("/repos/fresh"));
assert_eq!(req["worktree"]["branch"], json!("crimson-otter"));
assert_eq!(req["worktree"]["create_branch"], json!(true));
@@ -1691,9 +1665,10 @@ mod tests {
"the fallback is the spawn modal"
);
let draft = app.draft.as_ref().expect("a form behind the modal");
// Whatever did resolve (nothing project-side) is seeded; the
// generated name still lands so the form is ready to go.
assert_eq!(draft.name.value(), "amber-falcon");
// Whatever did resolve (nothing project-side) is seeded. The name
// field stays empty (#131); the handle seeds the branch instead.
assert_eq!(draft.name.value(), "");
assert_eq!(draft.branch.value(), "amber-falcon");
assert_eq!(draft.command(), "claude");
}
@@ -1893,7 +1868,7 @@ mod tests {
/// built-ins, projects land sorted, and the first generated name seeds
/// the field.
#[tokio::test]
async fn load_draft_data_fills_presets_projects_and_names() {
async fn load_draft_data_fills_presets_projects_and_the_branch_handle() {
use axum::routing::get;
use axum::Json;
use serde_json::json;
@@ -1946,7 +1921,12 @@ mod tests {
assert_eq!(draft.groups.len(), 1);
assert_eq!(draft.groups[0].main.name, "maestro");
assert_eq!(draft.home_dir, "/home/u");
assert_eq!(draft.name.value(), "crimson-otter");
assert_eq!(
draft.name.value(),
"",
"the operator names it, or nobody does"
);
assert_eq!(draft.branch.value(), "crimson-otter");
}
/// Keys fed while the form is not up must be ignored, not panic.
+97 -107
View File
@@ -10,7 +10,7 @@
//! entry), a two-step project/worktree picker (#96, mirroring the web
//! redesign in #95) fed by [`crate::projects`] over `/api/projects` plus an
//! `Other directory…` escape hatch, a generated session name from
//! `/api/names` with a reroll key, and validation that reports which field is
//! `/api/names` for the branch default, and validation that reports which field is
//! missing instead of posting an empty request. A worktree section (#65)
//! mirrors `web/src/spawnForm.ts`: on by default over a git repository,
//! branch tracking the generated name until touched, with a new-or-existing
@@ -36,7 +36,6 @@
//! 7. Neither step touches the command: the directory and what runs in it
//! are independent choices.
use std::collections::VecDeque;
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
@@ -53,10 +52,13 @@ use ratatui::Frame;
use crate::input::InputKey;
use crate::projects;
/// How many generated names one `/api/names` refill fetches. Rerolls consume
/// the local batch so they stay instant; the daemon is hit only when it runs
/// dry.
pub const NAME_BATCH_SIZE: usize = 20;
/// Shown in place of an empty name field: what happens if the operator types
/// nothing (#131).
pub const NAME_HINT: &str = "named after your first prompt";
/// How many handles one `/api/names` fetch asks for. One is enough: the name
/// field starts empty (#131) and the handle only seeds the worktree branch.
pub const NAME_BATCH_SIZE: usize = 1;
/// Quiet period after raw-path typing before a `/api/gitroot` probe fires
/// (#74). Every keystroke resets it, so a burst issues one request once the
@@ -234,11 +236,10 @@ pub struct DraftPane {
/// `selected_group_key` is `None`.
pub worktree_choice: WorktreeChoice,
pub name: crate::text_input::TextInput,
pub name_queue: VecDeque<String>,
/// Set once the operator types or rerolls a name; guards refills against
/// Set once the operator types a name; a fetched handle then seeds only
/// the branch, never the field. Guards a late fetch against
/// clobbering it, exactly like the web form's `nameTouched`.
pub name_touched: bool,
needs_name_refill: bool,
/// Worktree on for this spawn (#65). Defaults on; a failed gitroot probe
/// unticks it, like the web form.
pub worktree_enabled: bool,
@@ -302,9 +303,7 @@ impl Default for DraftPane {
selected_group_key: None,
worktree_choice: WorktreeChoice::New,
name: crate::text_input::TextInput::default(),
name_queue: VecDeque::new(),
name_touched: false,
needs_name_refill: false,
worktree_enabled: true,
advanced_collapsed: true,
base_repo: None,
@@ -388,30 +387,23 @@ impl DraftPane {
self.select_group(&group);
}
/// Fill the local name batch from `GET /api/names`, seeding the field
/// itself unless the operator already typed one.
pub fn seed_names(&mut self, names: Vec<String>) {
self.name_queue.extend(names);
if !self.name_touched && self.name.value().trim().is_empty() {
if let Some(first) = self.name_queue.pop_front() {
self.set_name(first);
}
}
}
/// Append a refill batch; the first name replaces the field (this only
/// happens after an explicit reroll on an empty batch).
/// Seed the worktree branch from a `GET /api/names` handle (#131).
///
/// The shown name is *consumed*, not left at the head — queueing it too
/// made the next reroll produce the same name and the key look dead
/// (#67 review).
pub fn extend_names(&mut self, mut names: Vec<String>) {
if names.is_empty() {
/// The name field is deliberately left alone: a session the operator does
/// not name is named by the daemon — a provisional handle at spawn,
/// replaced by one derived from the first prompt. The branch still needs
/// a default, and the name field no longer supplies one.
pub fn seed_names(&mut self, names: Vec<String>) {
let Some(handle) = names.into_iter().next() else {
return;
};
if self.branch_edited
|| self.branch_mode != WorktreeBranchMode::New
|| !self.branch.value().trim().is_empty()
{
return;
}
let first = names.remove(0);
self.set_name(first);
self.name_queue.extend(names);
self.branch = crate::text_input::TextInput::with_value(handle);
}
pub fn set_name(&mut self, name: impl Into<String>) {
@@ -421,27 +413,18 @@ impl DraftPane {
/// The new-branch field mirrors the session name until the operator types
/// their own branch — and only in `New` mode, like the web form.
///
/// A cleared name leaves the branch on its last value (#131): the branch
/// still has to be something, while the session name no longer does.
fn sync_branch_to_name(&mut self) {
if !self.branch_edited && self.branch_mode == WorktreeBranchMode::New {
if !self.branch_edited
&& self.branch_mode == WorktreeBranchMode::New
&& !self.name.value().is_empty()
{
self.branch = crate::text_input::TextInput::with_value(self.name.value().to_string());
}
}
/// Reroll the generated name. Pulls from the local batch; when it has run
/// dry, flags the caller to fetch a new one via [`Self::take_name_refill`].
pub fn reroll(&mut self) {
self.name_touched = true;
match self.name_queue.pop_front() {
Some(next) => self.set_name(next),
None => self.needs_name_refill = true,
}
}
/// Consume the reroll-needs-a-new-batch flag raised by [`Self::reroll`].
pub fn take_name_refill(&mut self) -> bool {
std::mem::take(&mut self.needs_name_refill)
}
// -- worktree (#65) -----------------------------------------------------
/// Whether the branch controls are shown: the toggle alone appears until
@@ -1070,12 +1053,6 @@ impl DraftPane {
self.move_branch_selection(1);
DraftInputResult::Consumed
}
InputKey::Char {
c: 'r', ctrl: true, ..
} if self.focused_field == DraftField::Name => {
self.reroll();
DraftInputResult::Consumed
}
other => {
match self.focused_field {
DraftField::Preset | DraftField::Submit => {}
@@ -1310,28 +1287,30 @@ impl DraftPane {
}
}
// -- name + reroll ---------------------------------------------------------
// -- name -----------------------------------------------------------------
let name_row = next_row();
draw_gutter(f, name_row, "name:");
let col = draw_text_field(f, &self.name, name_row, field_style(DraftField::Name));
if self.focused_field == DraftField::Name {
cursor = Some((col, name_row.y));
}
// Dim reroll hint, tucked after the typed name without covering it.
let hint_offset = (GUTTER as u16 + self.name.value().chars().count() as u16 + 1)
.min(name_row.width.saturating_sub(10));
f.render_widget(
Paragraph::new(Line::from(Span::styled(
"^R reroll",
Style::default().add_modifier(Modifier::DIM),
))),
Rect {
x: name_row.x + hint_offset,
y: name_row.y,
width: name_row.width.saturating_sub(hint_offset),
height: 1,
},
);
// An empty field is not a missing value (#131): the daemon names the
// session, so the row says so rather than looking unfinished.
if self.name.value().is_empty() {
let hint_offset = (GUTTER as u16 + 1).min(name_row.width.saturating_sub(10));
f.render_widget(
Paragraph::new(Line::from(Span::styled(
NAME_HINT,
Style::default().add_modifier(Modifier::DIM),
))),
Rect {
x: name_row.x + hint_offset,
y: name_row.y,
width: name_row.width.saturating_sub(hint_offset),
height: 1,
},
);
}
// -- advanced disclosure (#93) ------------------------------------------
let advanced_row = next_row();
@@ -2051,15 +2030,37 @@ mod tests {
assert_eq!(draft.cwd_raw.value(), "/repos/picked");
}
/// #131: the field stays empty and the request carries no name — the
/// daemon names the session. The fetched handle only seeds the branch.
#[test]
fn generated_names_seed_the_field_and_metadata() {
fn a_fetched_handle_seeds_the_branch_and_leaves_the_name_empty() {
let mut draft = DraftPane::default();
assert!(draft.name.value().is_empty());
draft.seed_names(vec!["crimson-otter".into()]);
assert!(
draft.name.value().is_empty(),
"no name until /api/names lands"
"the name field is the operator's"
);
draft.seed_names(vec!["crimson-otter".into(), "amber-falcon".into()]);
assert_eq!(draft.name.value(), "crimson-otter");
assert_eq!(draft.branch.value(), "crimson-otter");
draft.picked_cwd = Some(PathBuf::from("/w"));
draft.base_repo = Some(PathBuf::from("/w"));
draft.probed_cwd = Some(PathBuf::from("/w"));
let req = draft.build_request().unwrap();
assert!(
!req.metadata.contains_key("name"),
"an unnamed spawn sends no name"
);
}
/// A name the operator types still rides along, and still seeds the
/// branch (#131).
#[test]
fn a_typed_name_rides_along_and_seeds_the_branch() {
let mut draft = DraftPane::default();
typed_name(&mut draft, "my-session");
assert_eq!(draft.branch.value(), "my-session");
draft.picked_cwd = Some(PathBuf::from("/w"));
draft.base_repo = Some(PathBuf::from("/w"));
@@ -2067,36 +2068,19 @@ mod tests {
let req = draft.build_request().unwrap();
assert_eq!(
req.metadata.get("name").and_then(|v| v.as_str()),
Some("crimson-otter"),
"name rides along as metadata.name"
Some("my-session")
);
draft.reroll();
assert_eq!(
draft.name.value(),
"amber-falcon",
"reroll consumes the batch"
);
draft.reroll();
assert!(
draft.take_name_refill(),
"dry batch flags the caller to refetch"
);
assert!(!draft.take_name_refill(), "flag consumes");
}
/// A handle arriving after the operator typed a name never overwrites it,
/// nor the branch it seeded (#131).
#[test]
fn refills_do_not_clobber_a_name_the_operator_typed() {
fn a_late_handle_never_clobbers_what_was_typed() {
let mut draft = DraftPane::default();
draft.seed_names(vec!["seeded".into()]);
typed_name(&mut draft, "-mine");
assert_eq!(draft.name.value(), "seeded-mine");
draft.seed_names(vec!["late-batch".into()]);
assert_eq!(
draft.name.value(),
"seeded-mine",
"late initial batches never overwrite an edited name"
);
typed_name(&mut draft, "mine");
draft.seed_names(vec!["late-handle".into()]);
assert_eq!(draft.name.value(), "mine");
assert_eq!(draft.branch.value(), "mine");
}
fn typed_name(draft: &mut DraftPane, s: &str) {
@@ -2147,7 +2131,7 @@ mod tests {
}
#[test]
fn render_shows_every_field_group_and_the_reroll_hint() {
fn render_shows_every_field_group_and_the_naming_hint() {
let mut draft = DraftPane {
home_dir: "/home/u".into(),
..DraftPane::default()
@@ -2165,7 +2149,7 @@ mod tests {
"[Custom…]",
"dir:",
"name:",
"^R reroll",
NAME_HINT,
"maestro",
"[ Spawn ]",
] {
@@ -2453,18 +2437,24 @@ mod tests {
#[test]
fn the_new_branch_tracks_the_session_name_until_touched() {
let mut draft = DraftPane::default();
draft.seed_names(vec!["crimson-otter".into(), "amber-falcon".into()]);
draft.seed_names(vec!["crimson-otter".into()]);
assert_eq!(draft.branch.value(), "crimson-otter");
draft.reroll();
assert_eq!(draft.branch.value(), "amber-falcon", "rerolls carry over");
draft.focused_field = DraftField::Name;
typed(&mut draft, "renamed");
assert_eq!(
draft.branch.value(),
"renamed",
"the branch tracks the name"
);
draft.focused_field = DraftField::BranchNew;
typed(&mut draft, "-mine");
assert_eq!(draft.branch.value(), "amber-falcon-mine");
draft.seed_names(vec!["late-batch".into()]);
assert_eq!(draft.branch.value(), "renamed-mine");
draft.seed_names(vec!["late-handle".into()]);
assert_eq!(
draft.branch.value(),
"amber-falcon-mine",
"renamed-mine",
"an edited branch stops tracking the name"
);
}
+45 -40
View File
@@ -2,11 +2,13 @@
//!
//! The defaults mirror what the spawn form would settle on after the operator
//! picked the most recent project and kept their hands off everything else:
//! its last command (or the first non-custom preset), a freshly generated
//! name, and a worktree with a branch named after that name. Any default
//! that cannot be resolved — no projects yet, no command, no generated
//! name — downgrades the keystroke to the spawn form pre-filled with whatever
//! did resolve ([`FastForwardDefaults::apply_to_draft`]).
//! its last command (or the first non-custom preset), and a worktree on a new
//! branch named after a generated handle. The session itself is left unnamed
//! (#131) — the daemon gives it a provisional handle at spawn and names it
//! after its first prompt. Any default that cannot be resolved — no projects
//! yet, no command, no handle — downgrades the keystroke to the spawn form
//! pre-filled with whatever did resolve
//! ([`FastForwardDefaults::apply_to_draft`]).
use std::path::PathBuf;
@@ -21,16 +23,18 @@ use crate::draft::DraftPane;
pub struct FastForwardDefaults {
pub project: Option<Project>,
pub command: Option<String>,
pub name: Option<String>,
/// A generated handle for the worktree branch (#131). Not a session name:
/// the fast path names no session.
pub handle: Option<String>,
}
/// Resolve the fast-forward defaults from the daemon's answers. `name` is
/// Resolve the fast-forward defaults from the daemon's answers. `handle` is
/// `None` when `/api/names` yielded nothing; `presets` may be empty (the
/// caller falls back to the built-ins it already has).
pub fn resolve(
projects: &[Project],
presets: &[SpawnPreset],
name: Option<String>,
handle: Option<String>,
now: DateTime<Utc>,
) -> FastForwardDefaults {
let project = crate::projects::sort_projects(projects.to_vec(), now)
@@ -49,37 +53,35 @@ pub fn resolve(
FastForwardDefaults {
project,
command,
name,
handle,
}
}
impl FastForwardDefaults {
/// The spawn request when *every* default resolved: worktree on, new
/// branch named after the generated session name, base repo from the
/// scan (`None` means the project is itself a main checkout).
/// The spawn request when *every* default resolved: worktree on, a new
/// branch named after the generated handle, base repo from the scan
/// (`None` means the project is itself a main checkout).
///
/// The request carries no name (#131): the daemon assigns a provisional
/// one and replaces it once the session sees a prompt.
pub fn build_request(&self) -> Option<CreateSessionRequest> {
let project = self.project.as_ref()?;
let command = self.command.as_deref()?.trim();
let name = self.name.as_deref()?;
if command.is_empty() || name.is_empty() {
let handle = self.handle.as_deref()?;
if command.is_empty() || handle.is_empty() {
return None;
}
let mut metadata = std::collections::HashMap::new();
metadata.insert(
"name".to_string(),
serde_json::Value::String(name.to_string()),
);
Some(CreateSessionRequest {
cwd: project.path.clone(),
command: command.to_string(),
env: Default::default(),
metadata,
metadata: Default::default(),
worktree: Some(WorktreeSpec {
base_repo: project
.base_repo
.clone()
.unwrap_or_else(|| project.path.clone()),
branch: name.to_string(),
branch: handle.to_string(),
create_branch: true,
}),
})
@@ -109,10 +111,10 @@ impl FastForwardDefaults {
draft.custom_command = crate::text_input::TextInput::with_value(command);
}
}
if let Some(name) = &self.name {
draft.set_name(name.clone());
// Seeded, not generated: a later refill must not clobber it.
draft.name_touched = true;
if let Some(handle) = &self.handle {
// The branch, not the name: the form's name field stays empty so
// the session is named after its first prompt (#131).
draft.seed_names(vec![handle.clone()]);
}
}
}
@@ -161,19 +163,17 @@ mod tests {
PathBuf::from("/repos/fresh")
);
assert_eq!(r.command.as_deref(), Some("claude"));
assert_eq!(r.name.as_deref(), Some("amber-falcon"));
assert_eq!(r.handle.as_deref(), Some("amber-falcon"));
let req = r.build_request().expect("all defaults resolved");
assert_eq!(req.cwd, PathBuf::from("/repos/fresh"));
assert_eq!(req.command, "claude");
assert_eq!(
req.metadata.get("name").and_then(|v| v.as_str()),
Some("amber-falcon")
);
// #131: the fast path names no session — the daemon does.
assert!(req.metadata.is_empty());
let wt = req.worktree.expect("worktree on");
assert_eq!(wt.base_repo, PathBuf::from("/repos/fresh"));
assert_eq!(wt.branch, "amber-falcon");
assert!(wt.create_branch, "fresh branch named after the session");
assert!(wt.create_branch, "fresh branch named after the handle");
}
#[test]
@@ -243,31 +243,36 @@ mod tests {
assert!(draft.worktree_enabled);
}
/// The handle seeds the branch, never the name: a downgraded fast-forward
/// opens a form the operator can still leave unnamed (#131).
#[test]
fn a_resolved_name_survives_late_refills_and_tracks_the_branch() {
fn a_resolved_handle_seeds_the_branch_only() {
let projects = vec![project("/repos/p", 0, Some("claude"))];
let named = resolve(
let resolved = resolve(
&projects,
&[preset("claude", "claude")],
Some("amber-falcon".into()),
Utc::now(),
);
let mut draft = DraftPane::default();
named.apply_to_draft(&mut draft);
// A later batch must not overwrite the name the spawn was seeded with.
draft.seed_names(vec!["late-name".into()]);
assert_eq!(draft.name.value(), "amber-falcon");
resolved.apply_to_draft(&mut draft);
assert!(draft.name.value().is_empty());
assert_eq!(draft.branch.value(), "amber-falcon");
// A later handle finds the branch already seeded and leaves it.
draft.seed_names(vec!["late-handle".into()]);
assert_eq!(draft.branch.value(), "amber-falcon");
}
#[test]
fn an_unresolved_name_still_gets_generated_by_a_later_batch() {
fn an_unresolved_handle_still_arrives_from_a_later_batch() {
let projects = vec![project("/repos/p", 0, Some("claude"))];
let r = resolve(&projects, &[preset("claude", "claude")], None, Utc::now());
let mut draft = DraftPane::default();
r.apply_to_draft(&mut draft);
draft.seed_names(vec!["late-name".into()]);
assert_eq!(draft.name.value(), "late-name");
draft.seed_names(vec!["late-handle".into()]);
assert_eq!(draft.branch.value(), "late-handle");
assert!(draft.name.value().is_empty());
}
#[test]
+47 -1
View File
@@ -251,10 +251,23 @@ impl Sidebar {
),
Span::styled(format!("{glyph} "), base),
];
// #131: a name the daemon generated is provisional — the session's
// first prompt may replace it — so it reads muted, like the meta line,
// rather than as a name someone chose. See docs/SIDEBAR.md.
let name_style = if maestro_protocol::display::is_provisional_name(s) {
base.patch(
palette::active()
.surface(highlighted && focused)
.muted_style()
.bg(base.bg.unwrap_or(palette::active().chrome_bg)),
)
} else {
base
};
spans.extend(
fit_to_width(vec![Span::raw(name_for(s))], name_budget)
.into_iter()
.map(|sp| Span::styled(sp.content, base.patch(sp.style))),
.map(|sp| Span::styled(sp.content, name_style.patch(sp.style))),
);
pad_to_width(spans, width, base)
}
@@ -696,6 +709,39 @@ mod tests {
}
}
/// #131: a generated handle renders muted, a settled name in the card's
/// own foreground — the same distinction the web sidebar draws.
#[test]
fn a_generated_name_renders_muted_until_it_settles() {
let mut generated = session_named(1, "amber");
generated.metadata.insert(
maestro_protocol::NAME_SOURCE_KEY.into(),
serde_json::Value::String("Generated".into()),
);
let mut settled = session_named(2, "falcon");
settled.metadata.insert(
maestro_protocol::NAME_SOURCE_KEY.into(),
serde_json::Value::String("Haiku".into()),
);
let sb = Sidebar {
sessions: vec![generated, settled],
highlight: None,
attached: Default::default(),
};
let buf = draw(&sb, 44, 8);
let palette = palette::active();
let surface = palette.surface(false);
let colour_of = |needle: char| {
(0..buf.area.height)
.flat_map(|y| (0..buf.area.width).map(move |x| (x, y)))
.find(|&(x, y)| buf[(x, y)].symbol() == needle.to_string())
.map(|(x, y)| buf[(x, y)].fg)
.expect("name must be drawn")
};
assert_eq!(colour_of('a'), surface.muted, "the generated handle");
assert_ne!(colour_of('f'), surface.muted, "the settled name");
}
/// The additions and deletions are the only coloured fragments: they are
/// what a reader scans for, and colouring the rest would make the line
/// compete with the activity rail.