fix: report quick tasks in milliseconds

Durations under a second were rounded away, on the grounds that they are
noise. The visible result was a column where only the slow rows carried a
number, which reads as a fault rather than a decision, and it hid the
difference between a task that finished instantly and one that never ran.

Report milliseconds instead. A task that took three of them spent that
time starting a process and doing nothing, which is worth seeing.

The empty string had been doing double duty, standing for both "too
quick to matter" and "never started". Only the second keeps it, decided
by whether the task has a start time rather than by its duration.

Author: janluke

internal/tui/tui_test.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"testing"
 	"time"
@@ -300,7 +301,7 @@ func TestTUIModelShowsMultipleIndependentRoots(t *testing.T) {
 	m = updateTUIModel(t, m, started(4, 3, "unit"))
 
 	assert.Equal(t, []string{"build", "compile", "test", "unit"}, rowNames(m.taskRows()))
-	list := ansi.Strip(m.taskList(40, 10))
+	list := taskListWithoutDurations(t, m, 40, 10)
 	assert.Contains(t, list, "● build\n└─ ● compile")
 	assert.Contains(t, list, "● test\n└─ ● unit")
 }
@@ -1067,8 +1068,11 @@ func TestShortHelpKeepsTheWayOutOnANarrowTerminal(t *testing.T) {
 func TestFormatDuration(t *testing.T) {
 	t.Parallel()
 
-	// Sub-second timings are noise in a task runner.
-	assert.Empty(t, formatDuration(400*time.Millisecond))
+	// A quick task reports milliseconds rather than nothing, so every row that
+	// ran carries a number.
+	assert.Equal(t, "0ms", formatDuration(0))
+	assert.Equal(t, "3ms", formatDuration(3*time.Millisecond))
+	assert.Equal(t, "400ms", formatDuration(400*time.Millisecond))
 	assert.Equal(t, "3.4s", formatDuration(3400*time.Millisecond))
 	assert.Equal(t, "12s", formatDuration(12*time.Second))
 	assert.Equal(t, "1m35s", formatDuration(95*time.Second))
@@ -1215,3 +1219,30 @@ func TestFooterPairsTheArrowKeys(t *testing.T) {
 	assert.Equal(t, []string{"↑/↓", "←/→"}, keys[len(keys)-2:], "the arrows are adjacent and last")
 	assert.Equal(t, "pane", bindings[len(bindings)-1].Help().Desc)
 }
+
+// taskListWithoutDurations renders the task pane with the right-aligned
+// duration column trimmed, for assertions about names and tree structure.
+func taskListWithoutDurations(t *testing.T, m tuiModel, width, height int) string {
+	t.Helper()
+	var lines []string
+	for line := range strings.SplitSeq(ansi.Strip(m.taskList(width, height)), "\n") {
+		lines = append(lines, strings.TrimRight(regexp.
+			MustCompile(`\s+\d[\dhms.]*$`).
+			ReplaceAllString(line, ""), " "))
+	}
+	return strings.Join(lines, "\n")
+}
+
+func TestTUIModelReportsNoDurationForTasksThatNeverRan(t *testing.T) {
+	t.Parallel()
+
+	m := newTUIModel(func() {})
+	m = updateTUIModel(t, m, started(1, 0, "build"))
+	m = updateTUIModel(t, m, scheduledUnder(2, 1, 1, "never-attempted"))
+
+	// A task that ran has a duration even if it was instant; one that never
+	// started has none, which is different from a duration of zero.
+	assert.Equal(t, "0ms", m.durationLabel(m.byID[1]))
+	assert.Empty(t, m.durationLabel(m.byID[2]))
+	assert.NotContains(t, ansi.Strip(m.taskList(40, 10)), "never-attempted   0ms")
+}

internal/tui/view.go

@@ -213,7 +213,7 @@ func (m tuiModel) taskList(width, height int) string {
 		// The duration is right-aligned so durations line up and can be compared
 		// down the column. It is dropped rather than squeezing the name on a
 		// narrow pane.
-		duration := formatDuration(m.elapsed(row.task))
+		duration := m.durationLabel(row.task)
 		available := width - lipgloss.Width(plainPrefix)
 		durationWidth := 0
 		if duration != "" && available-lipgloss.Width(duration)-1 >= minTaskNameWidth {
@@ -347,17 +347,31 @@ func taskNameStatus(name string, state taskState, width int, showStatus bool) (s
 	return name, status
 }
 
+// durationLabel is how long a task ran, or nothing at all for one that never
+// started. A pending or skipped task has no duration to report, as opposed to a
+// duration of zero.
+func (m tuiModel) durationLabel(task *tuiTask) string {
+	if task.startedAt.IsZero() {
+		return ""
+	}
+	return formatDuration(m.elapsed(task))
+}
+
 // minTaskNameWidth is the room a name needs before a duration may take space
 // from it. Below that, knowing which task a row is matters more than knowing
 // how long it took.
 const minTaskNameWidth = 12
 
 // formatDuration renders how long a task ran, short enough for a narrow pane.
-// Anything under a second is noise in a task runner, so it is left out.
+//
+// Quick tasks are reported in milliseconds rather than rounded away. A task that
+// took three milliseconds spent that time starting a process and doing nothing,
+// which is worth seeing, and a column where only the slow rows carry a number
+// reads as a fault rather than a decision.
 func formatDuration(d time.Duration) string {
 	switch {
 	case d < time.Second:
-		return ""
+		return fmt.Sprintf("%dms", d.Milliseconds())
 	case d < 10*time.Second:
 		return fmt.Sprintf("%.1fs", d.Seconds())
 	case d < time.Minute:

website/src/next/docs/guide.md

@@ -2865,8 +2865,9 @@ the following controls to scroll:
 - Mouse wheel
 
 Each task shows how long it ran, counting up while it is running and keeping its
-final duration afterwards. On a narrow terminal the durations are dropped so
-that task names keep their space.
+final duration afterwards. Quick tasks are reported in milliseconds. A task that
+has not started has no duration, which is not the same as a duration of zero. On
+a narrow terminal the durations are dropped so that task names keep their space.
 
 Press `f` to show the selected task's output fullscreen. Incoming output remains
 visible; the view follows it while at the bottom and preserves the current