From 9ad045cd21d76fc0bea0b67dfd95cb0491d97689 Mon Sep 17 00:00:00 2001
From: Dima Kotlyarov <4886215+dimk0@users.noreply.github.com>
Date: Sat, 14 Nov 2026 02:40:48 +0000
Subject: [PATCH 1/4] air: Fit `air list` to narrow terminals by compacting and
 then hiding columns

After #7583 the interactive table shrinks Experiment and User to their
floors, but the other columns keep fixed widths, so below about 134
columns the rightmost columns are still cut off.

When the table is still too wide at the floors, two more tiers apply:

1. Compact: Started becomes `MM-DD HH:MM` and the MLflow column is sized
   to its widest stored label instead of a fixed 22 cells. Labels are not
   re-truncated, so they keep their end and retry note (#7582).
2. Hide: whole columns are dropped lowest priority first (Accelerators,
   User, MLflow, Progress) until the table fits. The hint line names the
   hidden columns; when the full key legend and that note do not both fit,
   the legend shortens to its keys.

After each step the spare cells go back to Experiment and User. Enter
still opens the row's MLflow link when the MLflow column is hidden.

The one-shot table (piped, NO_COLOR, --limit) and terminals wide enough
for today's table render exactly as before.

Verified with unit tests at 80, 100, 120, 133, 160 and 200 columns and by
running the CLI in a pty at those widths against e2-dogfood.

CNXT-2619

Co-authored-by: Isaac <no-reply@databricks.com>
---
 cmd/air/list_tui.go        |  25 +++-
 cmd/air/list_tui_render.go | 237 +++++++++++++++++++++++++++++++------
 cmd/air/list_tui_test.go   | 141 ++++++++++++++++++++++
 3 files changed, 358 insertions(+), 45 deletions(-)

diff --git a/cmd/air/list_tui.go b/cmd/air/list_tui.go
index 53ae3b3980f..1420d089c07 100644
--- a/cmd/air/list_tui.go
+++ b/cmd/air/list_tui.go
@@ -190,7 +190,7 @@ func (m listModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case tea.WindowSizeMsg:
 		m.height = msg.Height
 		m.width = msg.Width
-		m.cols = computeListCols(m.rows).fitWidth(m.width)
+		m.cols = layoutListCols(m.rows, m.width)
 		m.viewport.Width = msg.Width
 		m.viewport.Height = max(msg.Height-3, 1)
 		m.viewport.SetContent(m.wrappedDetail())
@@ -204,7 +204,7 @@ func (m listModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, nil
 		}
 		m.rows = append(m.rows, msg.rows...)
-		m.cols = computeListCols(m.rows).fitWidth(m.width)
+		m.cols = layoutListCols(m.rows, m.width)
 		m.offset = m.clampedOffset()
 		// A page with no matches but more to scan: keep paging so the cursor isn't
 		// stuck at the end of the loaded rows.
@@ -361,18 +361,31 @@ func (m listModel) View() string {
 	return strings.Join(lines, "\n") + "\n"
 }
 
-// renderHint is the faint one-line key legend, with the cursor position and the
-// paging state (loading / load failed).
+// renderHint is the faint one-line key legend, with the cursor position, the
+// columns a narrow terminal has hidden, and the paging state (loading / load
+// failed). When the full legend and the hidden-column note don't both fit the
+// terminal, the legend shortens to its keys so the note stays visible.
 func (m listModel) renderHint() string {
 	faint := m.styles.r.NewStyle().Foreground(colN7)
-	hint := fmt.Sprintf("↑/↓ navigate · ←/→ page · ↵ mlflow · i info · L logs · q quit  ·  row %d/%d", m.cursor+1, len(m.rows))
+	hint := m.hintText("↑/↓ navigate · ←/→ page · ↵ mlflow · i info · L logs · q quit")
+	if m.width > 0 && lipgloss.Width(hint) > m.width {
+		hint = m.hintText("↑/↓ ←/→ ↵ i L q")
+	}
+	return faint.Render(hint)
+}
+
+func (m listModel) hintText(legend string) string {
+	hint := fmt.Sprintf("%s  ·  row %d/%d", legend, m.cursor+1, len(m.rows))
+	if hidden := m.cols.hiddenNames(); len(hidden) > 0 {
+		hint += "  ·  hidden: " + strings.Join(hidden, ", ")
+	}
 	switch {
 	case m.loadErr != nil:
 		hint += " (load failed)"
 	case m.loading:
 		hint += " (loading…)"
 	}
-	return faint.Render(hint)
+	return hint
 }
 
 // fetchRunDetail returns a tea.Cmd that fetches run details in the background.
diff --git a/cmd/air/list_tui_render.go b/cmd/air/list_tui_render.go
index 2152663430d..8c8b54df671 100644
--- a/cmd/air/list_tui_render.go
+++ b/cmd/air/list_tui_render.go
@@ -35,16 +35,48 @@ func newListStyles(r *lipgloss.Renderer) listStyles {
 	return listStyles{r: r}
 }
 
-// listCols holds the computed width of each variable-width column. MLflow is
-// fixed (a short link) and the gutter is one cell.
+// listColumn identifies a table column, in display order.
+type listColumn int
+
+const (
+	columnRunID listColumn = iota
+	columnExperiment
+	columnStatus
+	columnStarted
+	columnDuration
+	columnProgress
+	columnMLflow
+	columnUser
+	columnAccel
+)
+
+// numListColumns is how many columns the table has.
+const numListColumns = int(columnAccel) + 1
+
+// listColumnNames are the header titles, indexed by listColumn.
+var listColumnNames = [numListColumns]string{
+	"Run ID", "Experiment", "Status", "Started", "Duration", "Progress", "MLflow", "User", "Accelerators",
+}
+
+// hideOrder lists the columns a too-narrow terminal drops, lowest priority
+// first.
+var hideOrder = []listColumn{columnAccel, columnUser, columnMLflow, columnProgress}
+
+// listCols holds the computed width of each column; the gutter is one cell.
+// compactStarted switches Started to its short form; hidden columns are left
+// out of the rendered rows.
 type listCols struct {
-	runID, experiment, status, started, duration, progress, user, accel int
+	runID, experiment, status, started, duration, progress, mlflow, user, accel int
+	compactStarted                                                              bool
+	hidden                                                                      uint16 // bit i set when listColumn i is hidden
 }
 
 // columnCap bounds the widest free-text columns so one long value can't dominate
 // the row.
 const columnCap = 36
 
+// computeListCols sizes every column to its content: the layout of the one-shot
+// table, and the starting point for fitting the interactive one.
 func computeListCols(rows []listRow) listCols {
 	c := listCols{
 		runID:      len("Run ID"),
@@ -53,6 +85,7 @@ func computeListCols(rows []listRow) listCols {
 		started:    len("Started"),
 		duration:   len("Duration"),
 		progress:   len("Progress"),
+		mlflow:     mlflowColWidth,
 		user:       len("User"),
 		accel:      len("Accelerators"),
 	}
@@ -76,12 +109,58 @@ const (
 	userMinWidth       = 8
 )
 
-// tableWidth is the full width of a rendered row: every column plus the gutter
-// and the two-cell separators.
+// width is the cell width of col.
+func (c listCols) width(col listColumn) int {
+	switch col {
+	case columnRunID:
+		return c.runID
+	case columnExperiment:
+		return c.experiment
+	case columnStatus:
+		return c.status
+	case columnStarted:
+		return c.started
+	case columnDuration:
+		return c.duration
+	case columnProgress:
+		return c.progress
+	case columnMLflow:
+		return c.mlflow
+	case columnUser:
+		return c.user
+	case columnAccel:
+		return c.accel
+	}
+	return 0
+}
+
+// shown reports whether col is part of the rendered table.
+func (c listCols) shown(col listColumn) bool {
+	return c.hidden&(1<<col) == 0
+}
+
+// hiddenNames lists the hidden columns' titles in table order; nil when every
+// column is shown.
+func (c listCols) hiddenNames() []string {
+	var names []string
+	for col := range listColumn(numListColumns) {
+		if !c.shown(col) {
+			names = append(names, listColumnNames[col])
+		}
+	}
+	return names
+}
+
+// tableWidth is the full width of a rendered row: the gutter plus every shown
+// column and its two-cell separator.
 func (c listCols) tableWidth() int {
-	const separators = 9 * 2
-	return 1 + c.runID + c.experiment + c.status + c.started + c.duration +
-		c.progress + mlflowColWidth + c.user + c.accel + separators
+	w := 1
+	for col := range listColumn(numListColumns) {
+		if c.shown(col) {
+			w += c.width(col) + 2
+		}
+	}
+	return w
 }
 
 // fitWidth shrinks the flexible columns (Experiment, User) until the table fits
@@ -97,7 +176,7 @@ func (c listCols) fitWidth(width int) listCols {
 	userFloor := min(c.user, userMinWidth)
 	for overflow := c.tableWidth() - width; overflow > 0; overflow-- {
 		canShrinkExperiment := c.experiment > experimentFloor
-		canShrinkUser := c.user > userFloor
+		canShrinkUser := c.shown(columnUser) && c.user > userFloor
 		switch {
 		case canShrinkExperiment && (!canShrinkUser || c.experiment >= c.user):
 			c.experiment--
@@ -110,22 +189,58 @@ func (c listCols) fitWidth(width int) listCols {
 	return c
 }
 
+// compact switches the fixed columns to their short forms: Started as
+// "MM-DD HH:MM" and MLflow as wide as its widest label rather than the full
+// mlflowColWidth. Labels were already cut to that width when the rows were
+// built, so they are never shortened again here.
+func (c listCols) compact(rows []listRow) listCols {
+	c.compactStarted = true
+	c.started = len("Started")
+	c.mlflow = len("MLflow")
+	for _, r := range rows {
+		c.started = max(c.started, lipgloss.Width(startedCompact(r)))
+		c.mlflow = max(c.mlflow, lipgloss.Width(mlflowLabel(r)))
+	}
+	return c
+}
+
+// layoutListCols lays the interactive table out for a terminal width cells
+// wide. Experiment and User shrink to their floors first; if the table is still
+// too wide the fixed columns compact, and then whole columns are hidden in
+// hideOrder until it fits. Each step gives its spare cells back to Experiment
+// and User. A terminal that fits today's table gets today's layout, and a width
+// of 0 (unknown) leaves the natural widths alone.
+func layoutListCols(rows []listRow, width int) listCols {
+	natural := computeListCols(rows)
+	if width <= 0 {
+		return natural
+	}
+	cols := natural.fitWidth(width)
+	if cols.tableWidth() <= width {
+		return cols
+	}
+	compact := natural.compact(rows)
+	cols = compact.fitWidth(width)
+	for _, col := range hideOrder {
+		if cols.tableWidth() <= width {
+			break
+		}
+		compact.hidden |= 1 << col
+		cols = compact.fitWidth(width)
+	}
+	return cols
+}
+
 // renderHeader renders the muted column-title row.
 func (s listStyles) renderHeader(cols listCols) string {
 	h := func(text string, width int, right bool) string {
 		return s.r.NewStyle().Foreground(colN9).Render(pad(text, width, right))
 	}
-	cells := []string{
-		pad(" ", 1, false),
-		h("Run ID", cols.runID, false),
-		h("Experiment", cols.experiment, false),
-		h("Status", cols.status, false),
-		h("Started", cols.started, false),
-		h("Duration", cols.duration, true),
-		h("Progress", cols.progress, true),
-		h("MLflow", mlflowColWidth, false),
-		h("User", cols.user, false),
-		h("Accelerators", cols.accel, false),
+	cells := []string{pad(" ", 1, false)}
+	for col := range listColumn(numListColumns) {
+		if cols.shown(col) {
+			cells = append(cells, h(listColumnNames[col], cols.width(col), col == columnDuration || col == columnProgress))
+		}
 	}
 	// Trim trailing pad on the final column so rows carry no trailing whitespace.
 	return strings.TrimRight(strings.Join(cells, "  "), " ")
@@ -161,17 +276,34 @@ func (s listStyles) renderRow(cols listCols, r listRow, selected, links bool) st
 
 	// Underline only cells that actually carry a link, so unlinked text isn't
 	// styled as clickable.
-	cells := []string{
-		s.cell(base, gutter, 1, fg(colN7), false, false, ""),
-		s.cell(base, r.RunID, cols.runID, fg(colRunID), false, runIDLink != "", runIDLink),
-		s.cell(base, r.Experiment, cols.experiment, fg(colN11), false, experimentLink != "", experimentLink),
-		s.cell(base, "● "+listRowStatus(r), cols.status, fg(statusColor(listRowStatus(r))), false, false, ""),
-		s.cell(base, startedDisplay(r), cols.started, fg(colN9), false, false, ""),
-		s.cell(base, r.Duration, cols.duration, fg(colN9), true, false, ""),
-		s.cell(base, progressDisplay(r), cols.progress, fg(colAmber), true, false, ""),
-		s.mlflowCell(base, r, selected, links),
-		s.cell(base, r.User, cols.user, fg(colN9), false, false, ""),
-		s.cell(base, r.Accelerators, cols.accel, fg(colN9), false, false, ""),
+	cell := func(col listColumn) string {
+		switch col {
+		case columnRunID:
+			return s.cell(base, r.RunID, cols.runID, fg(colRunID), false, runIDLink != "", runIDLink)
+		case columnExperiment:
+			return s.cell(base, r.Experiment, cols.experiment, fg(colN11), false, experimentLink != "", experimentLink)
+		case columnStatus:
+			return s.cell(base, "● "+listRowStatus(r), cols.status, fg(statusColor(listRowStatus(r))), false, false, "")
+		case columnStarted:
+			return s.cell(base, cols.startedText(r), cols.started, fg(colN9), false, false, "")
+		case columnDuration:
+			return s.cell(base, r.Duration, cols.duration, fg(colN9), true, false, "")
+		case columnProgress:
+			return s.cell(base, progressDisplay(r), cols.progress, fg(colAmber), true, false, "")
+		case columnMLflow:
+			return s.mlflowCell(base, cols.mlflow, r, selected, links)
+		case columnUser:
+			return s.cell(base, r.User, cols.user, fg(colN9), false, false, "")
+		case columnAccel:
+			return s.cell(base, r.Accelerators, cols.accel, fg(colN9), false, false, "")
+		}
+		return ""
+	}
+	cells := []string{s.cell(base, gutter, 1, fg(colN7), false, false, "")}
+	for col := range listColumn(numListColumns) {
+		if cols.shown(col) {
+			cells = append(cells, cell(col))
+		}
 	}
 	// Trim the final column's trailing pad so rows carry no trailing whitespace.
 	return strings.TrimRight(strings.Join(cells, base.Render("  ")), " ")
@@ -205,15 +337,15 @@ func (s listStyles) cell(base lipgloss.Style, text string, width int, fg lipglos
 	return rendered + padStr
 }
 
-// mlflowCell renders the fixed-width MLflow column: a short, blue, underlined
-// OSC 8 hyperlink (when links are enabled), or "-" when the run has no link.
-func (s listStyles) mlflowCell(base lipgloss.Style, r listRow, selected, links bool) string {
+// mlflowCell renders the MLflow column: a short, blue, underlined OSC 8
+// hyperlink (when links are enabled), or "-" when the run has no link.
+func (s listStyles) mlflowCell(base lipgloss.Style, width int, r listRow, selected, links bool) string {
 	if r.MLflowURL == "" || r.MLflowURL == "-" {
 		fg := colN9
 		if selected {
 			fg = colN12
 		}
-		return s.cell(base, "-", mlflowColWidth, fg, false, false, "")
+		return s.cell(base, "-", width, fg, false, false, "")
 	}
 	fg := colBlue
 	if selected {
@@ -223,11 +355,16 @@ func (s listStyles) mlflowCell(base lipgloss.Style, r listRow, selected, links b
 	if links {
 		link = r.MLflowURL
 	}
-	label := r.MLflowLabel
-	if label == "" || label == "-" {
-		label = "-"
+	return s.cell(base, mlflowLabel(r), width, fg, false, true, link)
+}
+
+// mlflowLabel is the text shown in the row's MLflow cell: its label, or "-"
+// when the run has no link or no label.
+func mlflowLabel(r listRow) string {
+	if r.MLflowURL == "" || r.MLflowURL == "-" || r.MLflowLabel == "" || r.MLflowLabel == "-" {
+		return "-"
 	}
-	return s.cell(base, label, mlflowColWidth, fg, false, true, link)
+	return r.MLflowLabel
 }
 
 // statusColor maps an air run status word to its data color.
@@ -266,6 +403,28 @@ func startedDisplay(r listRow) string {
 	return s
 }
 
+// startedCompact is the short form of the row's start timestamp for a narrow
+// terminal ("01-02 15:04"), or "-" when the run hasn't started. A timestamp too
+// short to carry a date and time is shown as is.
+func startedCompact(r listRow) string {
+	if r.StartedAt == nil {
+		return "-"
+	}
+	s := *r.StartedAt
+	if len(s) >= 16 {
+		return s[5:10] + " " + s[11:16]
+	}
+	return s
+}
+
+// startedText is the row's Started cell in the layout's long or compact form.
+func (c listCols) startedText(r listRow) string {
+	if c.compactStarted {
+		return startedCompact(r)
+	}
+	return startedDisplay(r)
+}
+
 // pad pads (or truncates) s to a visible width of n, right-aligned when right is
 // set. It measures visible width, so it is safe on styled strings.
 func pad(s string, n int, right bool) string {
diff --git a/cmd/air/list_tui_test.go b/cmd/air/list_tui_test.go
index 7117aabaec6..6893fddb776 100644
--- a/cmd/air/list_tui_test.go
+++ b/cmd/air/list_tui_test.go
@@ -472,3 +472,144 @@ func TestStaticListTableIgnoresTerminalWidth(t *testing.T) {
 	// The one-shot table still cuts a long Experiment at its end.
 	assert.Contains(t, lines[1], " /Users/someone.longname@example.com… ")
 }
+
+func TestLayoutListCols(t *testing.T) {
+	rows := wideListRows()
+	natural := computeListCols(rows)
+	require.Equal(t, 134, natural.fitWidth(134).tableWidth())
+
+	tests := []struct {
+		name           string
+		width          int
+		wantExperiment int
+		wantUser       int
+		wantCompact    bool
+		wantHidden     []string
+	}{
+		{name: "unknown width keeps natural columns", width: 0, wantExperiment: columnCap, wantUser: columnCap},
+		// Even at the floors the full table is 134 cells, so the compact tier
+		// applies and its 18 spare cells go back to Experiment and User.
+		{name: "133 compacts Started and MLflow", width: 133, wantExperiment: 18, wantUser: 19, wantCompact: true},
+		{name: "120 compacts and shows every column", width: 120, wantExperiment: 12, wantUser: 12, wantCompact: true},
+		// Hiding Accelerators alone leaves 102 cells, so User goes too and
+		// Experiment widens into the freed space.
+		{name: "100 hides Accelerators and User", width: 100, wantExperiment: 20, wantUser: 0, wantCompact: true, wantHidden: []string{"User", "Accelerators"}},
+		{name: "80 hides MLflow as well", width: 80, wantExperiment: 14, wantUser: 0, wantCompact: true, wantHidden: []string{"MLflow", "User", "Accelerators"}},
+		{name: "160 is unchanged from today", width: 160, wantExperiment: 23, wantUser: 23},
+		{name: "200 is unchanged from today", width: 200, wantExperiment: columnCap, wantUser: columnCap},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := layoutListCols(rows, tt.width)
+			assert.Equal(t, tt.wantExperiment, got.experiment)
+			if got.shown(columnUser) {
+				assert.Equal(t, tt.wantUser, got.user)
+			} else {
+				assert.Equal(t, 0, tt.wantUser, "User hidden but a width was expected")
+			}
+			assert.Equal(t, tt.wantCompact, got.compactStarted)
+			assert.Equal(t, tt.wantHidden, got.hiddenNames())
+			if tt.width > 0 {
+				assert.LessOrEqual(t, got.tableWidth(), tt.width)
+			}
+			if tt.wantCompact {
+				assert.Equal(t, 11, got.started)
+				assert.Equal(t, len("qwen-run-001"), got.mlflow, "MLflow is sized to its widest label")
+			} else {
+				// A terminal that fits today's table gets today's layout.
+				assert.Equal(t, natural.fitWidth(tt.width), got)
+				assert.Equal(t, mlflowColWidth, got.mlflow)
+			}
+		})
+	}
+}
+
+func TestLayoutListColsMLflowFloorIsHeader(t *testing.T) {
+	// With no MLflow links the compact column is just wide enough for its header.
+	rows := wideListRows()
+	for i := range rows {
+		rows[i].MLflowURL, rows[i].MLflowLabel = "-", "-"
+	}
+	got := layoutListCols(rows, 120)
+	assert.True(t, got.compactStarted)
+	assert.Equal(t, len("MLflow"), got.mlflow)
+}
+
+func TestStartedCompact(t *testing.T) {
+	assert.Equal(t, "-", startedCompact(listRow{}))
+	assert.Equal(t, "06-05 17:32", startedCompact(listRow{StartedAt: new("2026-06-05T17:32:39.000000+00:00")}))
+	assert.Equal(t, "2026-06", startedCompact(listRow{StartedAt: new("2026-06")}))
+}
+
+func TestRenderHidesColumns(t *testing.T) {
+	r, _ := cmdio.NewRenderer(cmdio.MockDiscard(t.Context()), io.Discard)
+	styles := newListStyles(r)
+	rows := wideListRows()
+	cols := layoutListCols(rows, 80)
+	require.Equal(t, []string{"MLflow", "User", "Accelerators"}, cols.hiddenNames())
+
+	header := styles.renderHeader(cols)
+	assert.Equal(t, cols.tableWidth(), ansi.StringWidth(header))
+	for _, name := range cols.hiddenNames() {
+		assert.NotContains(t, header, name)
+	}
+	assert.Contains(t, header, "Progress")
+
+	row := styles.renderRow(cols, rows[0], false, false)
+	assert.LessOrEqual(t, ansi.StringWidth(row), cols.tableWidth())
+	assert.Contains(t, row, "10-23 17:32")
+	assert.NotContains(t, row, "qwen-run-001")
+	assert.NotContains(t, row, "8x H100")
+}
+
+func TestListModelNarrowTerminalHidesColumns(t *testing.T) {
+	r, _ := cmdio.NewRenderer(cmdio.MockDiscard(t.Context()), io.Discard)
+	f := &runFetcher{ctx: t.Context(), exhausted: true}
+	m := newListModel(r, f, wideListRows(), false)
+
+	view := func(width int) []string {
+		next, _ := m.Update(tea.WindowSizeMsg{Width: width, Height: 30})
+		m = next.(listModel)
+		lines := strings.Split(strings.TrimRight(m.View(), "\n"), "\n")
+		require.Len(t, lines, 4) // header, two rows, hint
+		for _, line := range lines {
+			assert.LessOrEqual(t, ansi.StringWidth(line), width, line)
+		}
+		return lines
+	}
+
+	lines := view(80)
+	assert.NotContains(t, lines[0], "User")
+	assert.Contains(t, lines[3], "↑/↓ ←/→ ↵ i L q  ·  row 1/2  ·  hidden: MLflow, User, Accelerators")
+
+	lines = view(100)
+	assert.Contains(t, lines[0], "MLflow")
+	assert.Contains(t, lines[3], "hidden: User, Accelerators")
+
+	lines = view(120)
+	assert.Contains(t, lines[0], "Accelerators")
+	assert.Contains(t, lines[1], "10-23 17:32")
+	assert.Contains(t, lines[3], "↑/↓ navigate · ←/→ page · ↵ mlflow · i info · L logs · q quit  ·  row 1/2")
+	assert.NotContains(t, lines[3], "hidden")
+
+	// Widening past today's threshold restores the full timestamp.
+	lines = view(160)
+	assert.Contains(t, lines[1], "2026-10-23T17:32:39")
+}
+
+func TestListModelEnterOpensMLflowLogsWhenColumnHidden(t *testing.T) {
+	ctx, stderr := cmdio.NewTestContextWithStderr(t.Context())
+	ctx = env.Set(ctx, "BROWSER", "none")
+	r, _ := cmdio.NewRenderer(ctx, io.Discard)
+	f := &runFetcher{ctx: ctx, w: newTestWorkspaceClient(t, "https://x.test")}
+	m := newListModel(r, f, testListRows(), false)
+
+	next, _ := m.Update(tea.WindowSizeMsg{Width: 80, Height: 30})
+	m = next.(listModel)
+	require.False(t, m.cols.shown(columnMLflow))
+
+	_, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	require.NotNil(t, cmd)
+	cmd()
+	assert.Contains(t, stderr.String(), "https://h/ml/experiments/E/runs/04c41514fbb0/logs")
+}

From 77f2498738cf41339ba516d150dea95af52ce8a3 Mon Sep 17 00:00:00 2001
From: Dima Kotlyarov <4886215+dimk0@users.noreply.github.com>
Date: Sat, 14 Nov 2026 02:41:17 +0000
Subject: [PATCH 2/4] air: Add changelog fragment for #7629

Co-authored-by: Isaac <no-reply@databricks.com>
---
 .nextchanges/air/7629.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .nextchanges/air/7629.md

diff --git a/.nextchanges/air/7629.md b/.nextchanges/air/7629.md
new file mode 100644
index 00000000000..c420a218459
--- /dev/null
+++ b/.nextchanges/air/7629.md
@@ -0,0 +1 @@
+* Fit the interactive `air list` table to narrow terminals: when the Experiment and User columns are at their floors, shorten Started to `MM-DD HH:MM` and size the MLflow column to its labels, then hide Accelerators, User, MLflow and Progress in that order, naming the hidden columns in the hint line. ([#7629](https://github.com/databricks/cli/pull/7629))

From f7e7e29ae92977d68d2905ca166f337982804649 Mon Sep 17 00:00:00 2001
From: Dima Kotlyarov <4886215+dimk0@users.noreply.github.com>
Date: Sat, 14 Nov 2026 03:32:04 +0000
Subject: [PATCH 3/4] air: Keep the `air list` hint within the terminal and
 test the real MLflow label width

Review follow-ups for #7629.

The hint line could still run past the terminal, and bubbletea cut off
its end, which is where the loading / load-failed state sat. The hint
now gives up detail in steps until it fits: the legend shrinks to its
keys, then the hidden columns are counted instead of named, and as a
last resort the line is truncated. The variant is chosen for the widest
row counter and the loading state, so it does not flip as the cursor
moves or a page loads.

Tests now also cover the production case where every MLflow label is
the full 22 cells, the Progress tier, the still-too-wide case, a page
load that crosses a tier, the selected row in a reduced layout, and the
hint at 70, 75, 80 and 100 columns in every paging state.

Also: cap the compact MLflow width at mlflowColWidth, show a non-ISO
start timestamp as is instead of slicing it, decide right alignment in
one place, drop the duplicated link check in mlflowCell, and trim doc
comments.

Co-authored-by: Isaac <no-reply@databricks.com>
---
 cmd/air/list_tui.go        |  77 ++++++++++++----
 cmd/air/list_tui_render.go |  70 +++++++--------
 cmd/air/list_tui_test.go   | 174 +++++++++++++++++++++++++++++++++++--
 3 files changed, 262 insertions(+), 59 deletions(-)

diff --git a/cmd/air/list_tui.go b/cmd/air/list_tui.go
index 1420d089c07..af72e8cc6eb 100644
--- a/cmd/air/list_tui.go
+++ b/cmd/air/list_tui.go
@@ -204,6 +204,8 @@ func (m listModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, nil
 		}
 		m.rows = append(m.rows, msg.rows...)
+		// A new page can only widen the natural columns, so the layout moves one
+		// way as pages load: a column may compact or disappear, never reappear.
 		m.cols = layoutListCols(m.rows, m.width)
 		m.offset = m.clampedOffset()
 		// A page with no matches but more to scan: keep paging so the cursor isn't
@@ -361,31 +363,72 @@ func (m listModel) View() string {
 	return strings.Join(lines, "\n") + "\n"
 }
 
-// renderHint is the faint one-line key legend, with the cursor position, the
-// columns a narrow terminal has hidden, and the paging state (loading / load
-// failed). When the full legend and the hidden-column note don't both fit the
-// terminal, the legend shortens to its keys so the note stays visible.
+// Key legends for the hint line: the full one, and the keys alone for when the
+// full one leaves no room for the rest of the hint.
+const (
+	hintLegend      = "↑/↓ navigate · ←/→ page · ↵ mlflow · i info · L logs · q quit"
+	hintLegendShort = "↑/↓ ←/→ ↵ i L q"
+)
+
+// renderHint is the faint one-line hint: the key legend, the cursor position,
+// the paging state (loading / load failed) and, in a narrow terminal, the
+// columns the layout has hidden. It must fit the terminal, or bubbletea cuts
+// off its end, so it gives up detail in steps: the legend shrinks to its keys,
+// then the hidden columns are counted instead of named, and as a last resort
+// the line is truncated.
 func (m listModel) renderHint() string {
 	faint := m.styles.r.NewStyle().Foreground(colN7)
-	hint := m.hintText("↑/↓ navigate · ←/→ page · ↵ mlflow · i info · L logs · q quit")
-	if m.width > 0 && lipgloss.Width(hint) > m.width {
-		hint = m.hintText("↑/↓ ←/→ ↵ i L q")
+	hidden := m.cols.hiddenNames()
+	variants := []struct {
+		legend string
+		note   string
+	}{
+		{hintLegend, hiddenNote(hidden, true)},
+		{hintLegendShort, hiddenNote(hidden, true)},
+		{hintLegendShort, hiddenNote(hidden, false)},
 	}
-	return faint.Render(hint)
+	for _, v := range variants {
+		if m.width <= 0 || lipgloss.Width(m.hintText(v.legend, v.note, true)) <= m.width {
+			return faint.Render(m.hintText(v.legend, v.note, false))
+		}
+	}
+	last := variants[len(variants)-1]
+	return faint.Render(truncate(m.hintText(last.legend, last.note, false), m.width))
 }
 
-func (m listModel) hintText(legend string) string {
-	hint := fmt.Sprintf("%s  ·  row %d/%d", legend, m.cursor+1, len(m.rows))
-	if hidden := m.cols.hiddenNames(); len(hidden) > 0 {
-		hint += "  ·  hidden: " + strings.Join(hidden, ", ")
-	}
+// hintText assembles the hint from its legend and hidden-columns note. With
+// widest set, the row counter and paging state take the widest form they have
+// while pages load ("row N/N (loading…)"), so the choice of variant doesn't
+// change as the cursor moves or a page loads. A load failure is permanent, so
+// it is measured as is.
+func (m listModel) hintText(legend, note string, widest bool) string {
+	row, state := m.cursor+1, ""
 	switch {
 	case m.loadErr != nil:
-		hint += " (load failed)"
-	case m.loading:
-		hint += " (loading…)"
+		state = " (load failed)"
+	case widest, m.loading:
+		state = " (loading…)"
+	}
+	if widest {
+		row = len(m.rows)
+	}
+	return fmt.Sprintf("%s  ·  row %d/%d%s%s", legend, row, len(m.rows), state, note)
+}
+
+// hiddenNote is the hint's hidden-columns note: "" when every column is shown,
+// otherwise the hidden columns by name, or just their count when names is
+// false.
+func hiddenNote(hidden []string, names bool) string {
+	switch {
+	case len(hidden) == 0:
+		return ""
+	case names:
+		return "  ·  hidden: " + strings.Join(hidden, ", ")
+	case len(hidden) == 1:
+		return "  ·  1 column hidden"
+	default:
+		return fmt.Sprintf("  ·  %d columns hidden", len(hidden))
 	}
-	return hint
 }
 
 // fetchRunDetail returns a tea.Cmd that fetches run details in the background.
diff --git a/cmd/air/list_tui_render.go b/cmd/air/list_tui_render.go
index 8c8b54df671..7f70f5ce779 100644
--- a/cmd/air/list_tui_render.go
+++ b/cmd/air/list_tui_render.go
@@ -23,6 +23,8 @@ const (
 	colBlue    = lipgloss.Color("#6CA8F0") // MLflow link
 )
 
+// mlflowColWidth is the MLflow column's width in a wide terminal, and the width
+// MLflow labels are cut to when the rows are built.
 const mlflowColWidth = 22
 
 // listStyles renders the runs table. The renderer carries the color profile, so
@@ -50,10 +52,8 @@ const (
 	columnAccel
 )
 
-// numListColumns is how many columns the table has.
 const numListColumns = int(columnAccel) + 1
 
-// listColumnNames are the header titles, indexed by listColumn.
 var listColumnNames = [numListColumns]string{
 	"Run ID", "Experiment", "Status", "Started", "Duration", "Progress", "MLflow", "User", "Accelerators",
 }
@@ -75,8 +75,7 @@ type listCols struct {
 // the row.
 const columnCap = 36
 
-// computeListCols sizes every column to its content: the layout of the one-shot
-// table, and the starting point for fitting the interactive one.
+// computeListCols sizes every column to its content.
 func computeListCols(rows []listRow) listCols {
 	c := listCols{
 		runID:      len("Run ID"),
@@ -109,7 +108,6 @@ const (
 	userMinWidth       = 8
 )
 
-// width is the cell width of col.
 func (c listCols) width(col listColumn) int {
 	switch col {
 	case columnRunID:
@@ -134,13 +132,11 @@ func (c listCols) width(col listColumn) int {
 	return 0
 }
 
-// shown reports whether col is part of the rendered table.
 func (c listCols) shown(col listColumn) bool {
 	return c.hidden&(1<<col) == 0
 }
 
-// hiddenNames lists the hidden columns' titles in table order; nil when every
-// column is shown.
+// hiddenNames lists the hidden columns' titles in table order.
 func (c listCols) hiddenNames() []string {
 	var names []string
 	for col := range listColumn(numListColumns) {
@@ -151,6 +147,11 @@ func (c listCols) hiddenNames() []string {
 	return names
 }
 
+// rightAligned reports whether col's cells are right-aligned (the numeric ones).
+func rightAligned(col listColumn) bool {
+	return col == columnDuration || col == columnProgress
+}
+
 // tableWidth is the full width of a rendered row: the gutter plus every shown
 // column and its two-cell separator.
 func (c listCols) tableWidth() int {
@@ -163,11 +164,12 @@ func (c listCols) tableWidth() int {
 	return w
 }
 
-// fitWidth shrinks the flexible columns (Experiment, User) until the table fits
-// in width cells, so a long value truncates instead of pushing the columns to
-// its right off screen. It takes from the wider column first and stops at the
-// floors: a terminal too narrow for the fixed columns still overflows. A width
-// of 0 means the terminal size is unknown and leaves the columns alone.
+// fitWidth shrinks the flexible columns (Experiment, and User unless it is
+// hidden) until the table fits in width cells, so a long value truncates instead
+// of pushing the columns to its right off screen. It takes from the wider column
+// first and stops at the floors: a terminal too narrow for the fixed columns
+// still overflows. A width of 0 means the terminal size is unknown and leaves
+// the columns alone.
 func (c listCols) fitWidth(width int) listCols {
 	if width <= 0 {
 		return c
@@ -201,15 +203,17 @@ func (c listCols) compact(rows []listRow) listCols {
 		c.started = max(c.started, lipgloss.Width(startedCompact(r)))
 		c.mlflow = max(c.mlflow, lipgloss.Width(mlflowLabel(r)))
 	}
+	c.mlflow = min(c.mlflow, mlflowColWidth)
 	return c
 }
 
 // layoutListCols lays the interactive table out for a terminal width cells
-// wide. Experiment and User shrink to their floors first; if the table is still
-// too wide the fixed columns compact, and then whole columns are hidden in
-// hideOrder until it fits. Each step gives its spare cells back to Experiment
-// and User. A terminal that fits today's table gets today's layout, and a width
-// of 0 (unknown) leaves the natural widths alone.
+// wide. Experiment and User shrink to their floors first. If the table is still
+// too wide, the fixed columns compact, and then whole columns are hidden in
+// hideOrder until it fits or none are left to hide; after each of those steps
+// Experiment and User are refitted, so they widen into any spare cells. A
+// terminal wide enough for the uncompacted table gets exactly that, and a
+// width of 0 (unknown) leaves the natural widths alone.
 func layoutListCols(rows []listRow, width int) listCols {
 	natural := computeListCols(rows)
 	if width <= 0 {
@@ -239,7 +243,7 @@ func (s listStyles) renderHeader(cols listCols) string {
 	cells := []string{pad(" ", 1, false)}
 	for col := range listColumn(numListColumns) {
 		if cols.shown(col) {
-			cells = append(cells, h(listColumnNames[col], cols.width(col), col == columnDuration || col == columnProgress))
+			cells = append(cells, h(listColumnNames[col], cols.width(col), rightAligned(col)))
 		}
 	}
 	// Trim trailing pad on the final column so rows carry no trailing whitespace.
@@ -287,9 +291,9 @@ func (s listStyles) renderRow(cols listCols, r listRow, selected, links bool) st
 		case columnStarted:
 			return s.cell(base, cols.startedText(r), cols.started, fg(colN9), false, false, "")
 		case columnDuration:
-			return s.cell(base, r.Duration, cols.duration, fg(colN9), true, false, "")
+			return s.cell(base, r.Duration, cols.duration, fg(colN9), rightAligned(col), false, "")
 		case columnProgress:
-			return s.cell(base, progressDisplay(r), cols.progress, fg(colAmber), true, false, "")
+			return s.cell(base, progressDisplay(r), cols.progress, fg(colAmber), rightAligned(col), false, "")
 		case columnMLflow:
 			return s.mlflowCell(base, cols.mlflow, r, selected, links)
 		case columnUser:
@@ -340,22 +344,19 @@ func (s listStyles) cell(base lipgloss.Style, text string, width int, fg lipglos
 // mlflowCell renders the MLflow column: a short, blue, underlined OSC 8
 // hyperlink (when links are enabled), or "-" when the run has no link.
 func (s listStyles) mlflowCell(base lipgloss.Style, width int, r listRow, selected, links bool) string {
-	if r.MLflowURL == "" || r.MLflowURL == "-" {
-		fg := colN9
-		if selected {
-			fg = colN12
-		}
-		return s.cell(base, "-", width, fg, false, false, "")
-	}
+	label := mlflowLabel(r)
 	fg := colBlue
+	if label == "-" {
+		fg = colN9
+	}
 	if selected {
 		fg = colN12
 	}
 	link := ""
-	if links {
+	if links && label != "-" {
 		link = r.MLflowURL
 	}
-	return s.cell(base, mlflowLabel(r), width, fg, false, true, link)
+	return s.cell(base, label, width, fg, false, label != "-", link)
 }
 
 // mlflowLabel is the text shown in the row's MLflow cell: its label, or "-"
@@ -403,21 +404,20 @@ func startedDisplay(r listRow) string {
 	return s
 }
 
-// startedCompact is the short form of the row's start timestamp for a narrow
-// terminal ("01-02 15:04"), or "-" when the run hasn't started. A timestamp too
-// short to carry a date and time is shown as is.
+// startedCompact is the short form of the row's ISO start timestamp for a
+// narrow terminal ("01-02 15:04"), or "-" when the run hasn't started. A value
+// that isn't an ISO timestamp is shown as is.
 func startedCompact(r listRow) string {
 	if r.StartedAt == nil {
 		return "-"
 	}
 	s := *r.StartedAt
-	if len(s) >= 16 {
+	if len(s) >= 16 && s[4] == '-' && s[7] == '-' && s[10] == 'T' {
 		return s[5:10] + " " + s[11:16]
 	}
 	return s
 }
 
-// startedText is the row's Started cell in the layout's long or compact form.
 func (c listCols) startedText(r listRow) string {
 	if c.compactStarted {
 		return startedCompact(r)
diff --git a/cmd/air/list_tui_test.go b/cmd/air/list_tui_test.go
index 6893fddb776..213187f5320 100644
--- a/cmd/air/list_tui_test.go
+++ b/cmd/air/list_tui_test.go
@@ -1,12 +1,15 @@
 package aircmd
 
 import (
+	"errors"
+	"fmt"
 	"io"
 	"strconv"
 	"strings"
 	"testing"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 	"github.com/charmbracelet/x/ansi"
 	"github.com/databricks/cli/libs/cmdio"
 	"github.com/databricks/cli/libs/env"
@@ -485,16 +488,20 @@ func TestLayoutListCols(t *testing.T) {
 		wantUser       int
 		wantCompact    bool
 		wantHidden     []string
+		wantOverflow   bool
 	}{
 		{name: "unknown width keeps natural columns", width: 0, wantExperiment: columnCap, wantUser: columnCap},
 		// Even at the floors the full table is 134 cells, so the compact tier
-		// applies and its 18 spare cells go back to Experiment and User.
+		// applies and its 17 spare cells go back to Experiment and User.
 		{name: "133 compacts Started and MLflow", width: 133, wantExperiment: 18, wantUser: 19, wantCompact: true},
 		{name: "120 compacts and shows every column", width: 120, wantExperiment: 12, wantUser: 12, wantCompact: true},
 		// Hiding Accelerators alone leaves 102 cells, so User goes too and
 		// Experiment widens into the freed space.
 		{name: "100 hides Accelerators and User", width: 100, wantExperiment: 20, wantUser: 0, wantCompact: true, wantHidden: []string{"User", "Accelerators"}},
 		{name: "80 hides MLflow as well", width: 80, wantExperiment: 14, wantUser: 0, wantCompact: true, wantHidden: []string{"MLflow", "User", "Accelerators"}},
+		// With every hideable column gone the table is 66 cells, so it still
+		// overflows and the floors hold.
+		{name: "60 hides Progress and still overflows", width: 60, wantExperiment: experimentMinWidth, wantUser: 0, wantCompact: true, wantHidden: []string{"Progress", "MLflow", "User", "Accelerators"}, wantOverflow: true},
 		{name: "160 is unchanged from today", width: 160, wantExperiment: 23, wantUser: 23},
 		{name: "200 is unchanged from today", width: 200, wantExperiment: columnCap, wantUser: columnCap},
 	}
@@ -509,7 +516,10 @@ func TestLayoutListCols(t *testing.T) {
 			}
 			assert.Equal(t, tt.wantCompact, got.compactStarted)
 			assert.Equal(t, tt.wantHidden, got.hiddenNames())
-			if tt.width > 0 {
+			switch {
+			case tt.wantOverflow:
+				assert.Greater(t, got.tableWidth(), tt.width)
+			case tt.width > 0:
 				assert.LessOrEqual(t, got.tableWidth(), tt.width)
 			}
 			if tt.wantCompact {
@@ -524,6 +534,70 @@ func TestLayoutListCols(t *testing.T) {
 	}
 }
 
+// fullLabelListRows is wideListRows with MLflow labels at the full
+// mlflowColWidth, which is what list.go produces for every linked run: real
+// data never gets the short labels the other fixtures use, so compacting saves
+// only the 8 cells of Started.
+func fullLabelListRows() []listRow {
+	rows := wideListRows()
+	for i := range rows {
+		if rows[i].MLflowURL != "-" {
+			rows[i].MLflowLabel = "…ne-2026-10-23-lr-3e-5"
+			if lipgloss.Width(rows[i].MLflowLabel) != mlflowColWidth {
+				panic("fixture label is not mlflowColWidth cells wide")
+			}
+		}
+	}
+	return rows
+}
+
+func TestLayoutListColsFullLabels(t *testing.T) {
+	rows := fullLabelListRows()
+	tests := []struct {
+		name           string
+		width          int
+		wantExperiment int
+		wantUser       int
+		wantHidden     []string
+	}{
+		{name: "133 compacts Started only", width: 133, wantExperiment: 13, wantUser: 14},
+		{name: "126 is the narrowest compact fit", width: 126, wantExperiment: experimentMinWidth, wantUser: userMinWidth},
+		{name: "125 hides Accelerators", width: 125, wantExperiment: 16, wantUser: 17, wantHidden: []string{"Accelerators"}},
+		{name: "120 hides Accelerators", width: 120, wantExperiment: 14, wantUser: 14, wantHidden: []string{"Accelerators"}},
+		{name: "100 hides MLflow and User too", width: 100, wantExperiment: 34, wantHidden: []string{"MLflow", "User", "Accelerators"}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := layoutListCols(rows, tt.width)
+			assert.True(t, got.compactStarted)
+			assert.Equal(t, mlflowColWidth, got.mlflow)
+			assert.Equal(t, tt.wantExperiment, got.experiment)
+			if got.shown(columnUser) {
+				assert.Equal(t, tt.wantUser, got.user)
+			}
+			assert.Equal(t, tt.wantHidden, got.hiddenNames())
+			assert.LessOrEqual(t, got.tableWidth(), tt.width)
+		})
+	}
+}
+
+func TestLayoutListColsMovesOneWayAsPagesLoad(t *testing.T) {
+	// Loading more rows can only widen the natural columns, so a column that
+	// is hidden stays hidden and a compact layout stays compact.
+	rows := wideListRows()
+	for _, width := range []int{80, 100, 120, 133, 160} {
+		first := layoutListCols(rows[1:], width)
+		all := layoutListCols(rows, width)
+		assert.Equal(t, first.hidden, first.hidden&all.hidden, "width %d: a hidden column reappeared", width)
+		if first.compactStarted {
+			assert.True(t, all.compactStarted, "width %d: Started widened again", width)
+		}
+	}
+	// The sample does cross a tier: the second page hides User at 100 columns.
+	assert.Equal(t, []string{"Accelerators"}, layoutListCols(rows[1:], 100).hiddenNames())
+	assert.Equal(t, []string{"User", "Accelerators"}, layoutListCols(rows, 100).hiddenNames())
+}
+
 func TestLayoutListColsMLflowFloorIsHeader(t *testing.T) {
 	// With no MLflow links the compact column is just wide enough for its header.
 	rows := wideListRows()
@@ -539,6 +613,15 @@ func TestStartedCompact(t *testing.T) {
 	assert.Equal(t, "-", startedCompact(listRow{}))
 	assert.Equal(t, "06-05 17:32", startedCompact(listRow{StartedAt: new("2026-06-05T17:32:39.000000+00:00")}))
 	assert.Equal(t, "2026-06", startedCompact(listRow{StartedAt: new("2026-06")}))
+	assert.Equal(t, "Mon Jan  2 15:04:05 2006", startedCompact(listRow{StartedAt: new("Mon Jan  2 15:04:05 2006")}))
+}
+
+func TestHiddenNote(t *testing.T) {
+	assert.Empty(t, hiddenNote(nil, true))
+	assert.Empty(t, hiddenNote(nil, false))
+	assert.Equal(t, "  ·  hidden: User, Accelerators", hiddenNote([]string{"User", "Accelerators"}, true))
+	assert.Equal(t, "  ·  1 column hidden", hiddenNote([]string{"Accelerators"}, false))
+	assert.Equal(t, "  ·  2 columns hidden", hiddenNote([]string{"User", "Accelerators"}, false))
 }
 
 func TestRenderHidesColumns(t *testing.T) {
@@ -555,11 +638,15 @@ func TestRenderHidesColumns(t *testing.T) {
 	}
 	assert.Contains(t, header, "Progress")
 
-	row := styles.renderRow(cols, rows[0], false, false)
-	assert.LessOrEqual(t, ansi.StringWidth(row), cols.tableWidth())
-	assert.Contains(t, row, "10-23 17:32")
-	assert.NotContains(t, row, "qwen-run-001")
-	assert.NotContains(t, row, "8x H100")
+	for _, selected := range []bool{false, true} {
+		row := styles.renderRow(cols, rows[0], selected, true)
+		assert.LessOrEqual(t, ansi.StringWidth(row), cols.tableWidth())
+		assert.Contains(t, row, "10-23 17:32")
+		assert.NotContains(t, row, "qwen-run-001")
+		assert.NotContains(t, row, "8x H100")
+		assert.NotContains(t, row, "runs/04c41514fbb0", "a hidden MLflow column carries no hyperlink")
+	}
+	assert.True(t, strings.HasPrefix(styles.renderRow(cols, rows[0], true, false), "▸"))
 }
 
 func TestListModelNarrowTerminalHidesColumns(t *testing.T) {
@@ -597,6 +684,79 @@ func TestListModelNarrowTerminalHidesColumns(t *testing.T) {
 	assert.Contains(t, lines[1], "2026-10-23T17:32:39")
 }
 
+func TestListModelHintNamesHiddenColumnsWithFullLegend(t *testing.T) {
+	r, _ := cmdio.NewRenderer(cmdio.MockDiscard(t.Context()), io.Discard)
+	f := &runFetcher{ctx: t.Context(), exhausted: true}
+	m := newListModel(r, f, fullLabelListRows(), false)
+	next, _ := m.Update(tea.WindowSizeMsg{Width: 120, Height: 30})
+	m = next.(listModel)
+	lines := strings.Split(strings.TrimRight(m.View(), "\n"), "\n")
+	require.Len(t, lines, 4)
+	assert.NotContains(t, lines[0], "Accelerators")
+	assert.Contains(t, lines[0], "MLflow")
+	assert.Equal(t, hintLegend+"  ·  row 1/2  ·  hidden: Accelerators", lines[3])
+	assert.LessOrEqual(t, ansi.StringWidth(lines[3]), 120)
+}
+
+func TestListModelHintFitsNarrowTerminal(t *testing.T) {
+	r, _ := cmdio.NewRenderer(cmdio.MockDiscard(t.Context()), io.Discard)
+	// Enough rows for a three-digit counter, all with wide values so every
+	// hideable column goes at the narrowest widths.
+	var rows []listRow
+	for len(rows) < 120 {
+		rows = append(rows, wideListRows()...)
+	}
+	for _, width := range []int{70, 75, 80, 100} {
+		for _, state := range []string{"idle", "loading", "failed"} {
+			t.Run(fmt.Sprintf("%d/%s", width, state), func(t *testing.T) {
+				f := &runFetcher{ctx: t.Context(), exhausted: true}
+				m := newListModel(r, f, rows, false)
+				next, _ := m.Update(tea.WindowSizeMsg{Width: width, Height: 30})
+				m = next.(listModel)
+				switch state {
+				case "loading":
+					m.loading = true
+				case "failed":
+					m.loadErr = errors.New("boom")
+				}
+				m.cursor = len(rows) - 1
+				hint := m.renderHint()
+				assert.LessOrEqual(t, ansi.StringWidth(hint), width, hint)
+				assert.Contains(t, hint, "row 120/120")
+				assert.True(t, strings.Contains(hint, "hidden: ") || strings.Contains(hint, "columns hidden"), hint)
+				switch state {
+				case "loading":
+					assert.Contains(t, hint, "(loading…)")
+				case "failed":
+					assert.Contains(t, hint, "(load failed)")
+				}
+				// The variant is chosen for the widest counter and the loading
+				// state, so it doesn't change while a page loads.
+				idle, loading := m, m
+				idle.loading, loading.loading = false, true
+				assert.Equal(t, strings.Contains(idle.renderHint(), hintLegend), strings.Contains(loading.renderHint(), hintLegend))
+			})
+		}
+	}
+}
+
+func TestListModelRelayoutsLoadedPageInNarrowTerminal(t *testing.T) {
+	r, _ := cmdio.NewRenderer(cmdio.MockDiscard(t.Context()), io.Discard)
+	rows := wideListRows()
+	f := &runFetcher{ctx: t.Context(), exhausted: true}
+	m := newListModel(r, f, rows[1:], false)
+	next, _ := m.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	m = next.(listModel)
+	require.Equal(t, []string{"Accelerators"}, m.cols.hiddenNames())
+
+	next, _ = m.Update(moreRowsMsg{rows: rows[:1]})
+	m = next.(listModel)
+	assert.Equal(t, []string{"User", "Accelerators"}, m.cols.hiddenNames())
+	for line := range strings.SplitSeq(strings.TrimRight(m.View(), "\n"), "\n") {
+		assert.LessOrEqual(t, ansi.StringWidth(line), 100, line)
+	}
+}
+
 func TestListModelEnterOpensMLflowLogsWhenColumnHidden(t *testing.T) {
 	ctx, stderr := cmdio.NewTestContextWithStderr(t.Context())
 	ctx = env.Set(ctx, "BROWSER", "none")

From 74de95fcbf94a95466eac5ddbb51241ad2ddba8f Mon Sep 17 00:00:00 2001
From: Dima Kotlyarov <4886215+dimk0@users.noreply.github.com>
Date: Sat, 14 Nov 2026 03:40:10 +0000
Subject: [PATCH 4/4] air: Keep the `air list` row counter and paging state
 when the hint has no room for a legend

Below the width where even the short legend fits, the hint now drops the
legend before truncating, so the row counter and loading / load-failed
state stay visible. Also test the MLflow width cap, compare whole hints
in the stability check, and say that mlflowColWidth is the widest label
list.go produces rather than the only one.

Co-authored-by: Isaac <no-reply@databricks.com>
---
 cmd/air/list_tui.go      | 21 +++++++++++++--------
 cmd/air/list_tui_test.go | 37 +++++++++++++++++++++++++++----------
 2 files changed, 40 insertions(+), 18 deletions(-)

diff --git a/cmd/air/list_tui.go b/cmd/air/list_tui.go
index af72e8cc6eb..505a329bdeb 100644
--- a/cmd/air/list_tui.go
+++ b/cmd/air/list_tui.go
@@ -374,8 +374,8 @@ const (
 // the paging state (loading / load failed) and, in a narrow terminal, the
 // columns the layout has hidden. It must fit the terminal, or bubbletea cuts
 // off its end, so it gives up detail in steps: the legend shrinks to its keys,
-// then the hidden columns are counted instead of named, and as a last resort
-// the line is truncated.
+// then the hidden columns are counted instead of named, then the legend goes,
+// and as a last resort the line is truncated.
 func (m listModel) renderHint() string {
 	faint := m.styles.r.NewStyle().Foreground(colN7)
 	hidden := m.cols.hiddenNames()
@@ -386,6 +386,7 @@ func (m listModel) renderHint() string {
 		{hintLegend, hiddenNote(hidden, true)},
 		{hintLegendShort, hiddenNote(hidden, true)},
 		{hintLegendShort, hiddenNote(hidden, false)},
+		{"", hiddenNote(hidden, false)},
 	}
 	for _, v := range variants {
 		if m.width <= 0 || lipgloss.Width(m.hintText(v.legend, v.note, true)) <= m.width {
@@ -396,11 +397,11 @@ func (m listModel) renderHint() string {
 	return faint.Render(truncate(m.hintText(last.legend, last.note, false), m.width))
 }
 
-// hintText assembles the hint from its legend and hidden-columns note. With
-// widest set, the row counter and paging state take the widest form they have
-// while pages load ("row N/N (loading…)"), so the choice of variant doesn't
-// change as the cursor moves or a page loads. A load failure is permanent, so
-// it is measured as is.
+// hintText assembles the hint from its (possibly empty) legend and
+// hidden-columns note. With widest set, the row counter and paging state take
+// the widest form they have while pages load ("row N/N (loading…)"), so the
+// choice of variant doesn't change as the cursor moves or a page loads. A load
+// failure is permanent, so it is measured as is.
 func (m listModel) hintText(legend, note string, widest bool) string {
 	row, state := m.cursor+1, ""
 	switch {
@@ -412,7 +413,11 @@ func (m listModel) hintText(legend, note string, widest bool) string {
 	if widest {
 		row = len(m.rows)
 	}
-	return fmt.Sprintf("%s  ·  row %d/%d%s%s", legend, row, len(m.rows), state, note)
+	hint := fmt.Sprintf("row %d/%d%s%s", row, len(m.rows), state, note)
+	if legend == "" {
+		return hint
+	}
+	return legend + "  ·  " + hint
 }
 
 // hiddenNote is the hint's hidden-columns note: "" when every column is shown,
diff --git a/cmd/air/list_tui_test.go b/cmd/air/list_tui_test.go
index 213187f5320..b7c0cab1f7d 100644
--- a/cmd/air/list_tui_test.go
+++ b/cmd/air/list_tui_test.go
@@ -534,10 +534,9 @@ func TestLayoutListCols(t *testing.T) {
 	}
 }
 
-// fullLabelListRows is wideListRows with MLflow labels at the full
-// mlflowColWidth, which is what list.go produces for every linked run: real
-// data never gets the short labels the other fixtures use, so compacting saves
-// only the 8 cells of Started.
+// fullLabelListRows is wideListRows with MLflow labels at mlflowColWidth, the
+// widest list.go produces and the usual case for a run named by MLflow. With
+// these labels compacting saves only the 8 cells of Started.
 func fullLabelListRows() []listRow {
 	rows := wideListRows()
 	for i := range rows {
@@ -598,6 +597,13 @@ func TestLayoutListColsMovesOneWayAsPagesLoad(t *testing.T) {
 	assert.Equal(t, []string{"User", "Accelerators"}, layoutListCols(rows, 100).hiddenNames())
 }
 
+func TestLayoutListColsCapsMLflowAtColumnWidth(t *testing.T) {
+	// A label wider than the column (none is built that way) never widens it.
+	rows := wideListRows()
+	rows[0].MLflowLabel = strings.Repeat("x", mlflowColWidth+5)
+	assert.Equal(t, mlflowColWidth, layoutListCols(rows, 120).mlflow)
+}
+
 func TestLayoutListColsMLflowFloorIsHeader(t *testing.T) {
 	// With no MLflow links the compact column is just wide enough for its header.
 	rows := wideListRows()
@@ -706,7 +712,7 @@ func TestListModelHintFitsNarrowTerminal(t *testing.T) {
 	for len(rows) < 120 {
 		rows = append(rows, wideListRows()...)
 	}
-	for _, width := range []int{70, 75, 80, 100} {
+	for _, width := range []int{40, 46, 70, 75, 80, 100} {
 		for _, state := range []string{"idle", "loading", "failed"} {
 			t.Run(fmt.Sprintf("%d/%s", width, state), func(t *testing.T) {
 				f := &runFetcher{ctx: t.Context(), exhausted: true}
@@ -722,19 +728,30 @@ func TestListModelHintFitsNarrowTerminal(t *testing.T) {
 				m.cursor = len(rows) - 1
 				hint := m.renderHint()
 				assert.LessOrEqual(t, ansi.StringWidth(hint), width, hint)
+				// The row counter and paging state come first, so they survive
+				// every step down.
 				assert.Contains(t, hint, "row 120/120")
-				assert.True(t, strings.Contains(hint, "hidden: ") || strings.Contains(hint, "columns hidden"), hint)
 				switch state {
 				case "loading":
 					assert.Contains(t, hint, "(loading…)")
 				case "failed":
 					assert.Contains(t, hint, "(load failed)")
 				}
-				// The variant is chosen for the widest counter and the loading
-				// state, so it doesn't change while a page loads.
+				// Only the last-resort truncation, which needs a terminal
+				// narrower than the table's own minimum, can cut the note or
+				// make the idle and loading hints differ. Otherwise the variant
+				// is chosen for the widest counter and the loading state, so it
+				// doesn't change while a page loads.
 				idle, loading := m, m
-				idle.loading, loading.loading = false, true
-				assert.Equal(t, strings.Contains(idle.renderHint(), hintLegend), strings.Contains(loading.renderHint(), hintLegend))
+				idle.loading, idle.loadErr = false, nil
+				loading.loading, loading.loadErr = true, nil
+				loadingHint := loading.renderHint()
+				if strings.HasSuffix(loadingHint, "…") || strings.HasSuffix(hint, "…") {
+					assert.Less(t, width, 48, hint)
+					return
+				}
+				assert.True(t, strings.Contains(hint, "hidden: ") || strings.Contains(hint, "columns hidden"), hint)
+				assert.Equal(t, idle.renderHint(), strings.Replace(loadingHint, " (loading…)", "", 1))
 			})
 		}
 	}