feat(client): show request log events in list and watch

## Summary

### Why?

A request's history holds two kinds of entry. A **status** is a position it reached — `batched`, `speculating`, `landed` — and a **event** is something that happened while it sat at one: a build starting, a build finishing, a passed path waiting on a dependency that has not resolved.

The table only ever showed the first kind. `digest` skipped every entry whose status was empty, which is exactly what an event is, so the whole second half of the request log was dropped on the floor. Two requests that both read `speculating → speculated → landed` could have done wildly different amounts of work — one build or eight — and the table said the same thing about both.

`list` showed less still. It reads the queue's receipts rather than a history per request, so its trail was empty and its `STAGE` column rendered `…` for every row, including rows whose current status it already had in hand.

### What?

**Events are shown against the status they happened under**, rather than as steps of their own, because they are not positions and treating them as such would imply the request moved:

```
batched → speculating [building ×8, built ×8, waiting] → speculated → landing → landed
```

Repeats are counted rather than listed. A batch runs one build per speculation path, so a request that speculated widely records `building` many times over, and spelling each one out would say less than the count does while pushing the rest of the row off the line. Eight builds is the interesting fact; eight words are not.

**`list` shows the position each request holds** instead of `…`. It still fetches no histories — that is what keeps a listing one round trip — so it reports where a request is without claiming to know how it got there.

The quickstart's description of the two commands is updated, including a claim about `list` that this makes false.

## Test Plan

- ✅ `make demo-requests COUNT=4 FOLDERS=1` against a live stack, which forces every change to conflict and so produces real speculation. The deepest request in the chain rendered `speculating [building ×8, built ×8, waiting]` while the first rendered `speculating [building, built]` — the difference this change exists to show
- ✅ `make land-list` mid-flight reports `speculating` where it used to report `…`, and `landed` once the run settled
- ✅ new `digest` cases: events attach to the status they occurred under, repeats are counted, a status repeated around its own events stays one step, each status collects only its own events, an event does not move the request off its status, an event before any status is dropped, and an error carried by an event is still surfaced
- ✅ new `stage` cases for the bare position and for a fetched trail taking precedence
- ✅ `make test` (105 targets), `make lint`, `make gazelle`

Author: behinddwalls

doc/howto/QUICKSTART.md

@@ -105,7 +105,16 @@ make land-list SINCE=24h LIMIT=200   # a wider window
 make land-watch                      # follow them until they settle
 ```
 
-Both draw the same table `make demo-requests` does — the demo tool and the CLI share it — but against whatever the queue already holds, so watching a queue no longer means adding to it. They do not carry the same information, though: `list` is a one-shot read of the queue's receipts and does not fetch histories, so its `STAGE` column is always `…`, while `watch` follows the history API and fills the trail in as each request moves.
+Both draw the same table `make demo-requests` does — the demo tool and the CLI share it — but against whatever the queue already holds, so watching a queue no longer means adding to it. They do not carry the same information, though: `list` is a one-shot read of the queue's receipts and does not fetch a history per request, so its `STAGE` column shows where each request is and not how it got there, while `watch` follows the history API and fills the whole trail in as each one moves.
+
+That trail carries more than positions. A request records events while it sits at one — a build starting or finishing, a passed path waiting on a dependency — and those are shown against the status they happened under, with repeats counted:
+
+```
+accepted → started → validating → validated → batching → batched →
+speculating [building ×8, built ×8, waiting] → speculated → landing → landed
+```
+
+Eight builds means the batch was speculating down eight paths at once, and `waiting` means one of them passed and then sat on a dependency that had not resolved. A request that sailed through reads `speculating [building, built]` instead — the same position, a very different amount of work behind it.
 
 `land-watch` fixes its set when it starts and exits non-zero if any request in that set finishes anywhere other than `landed`, which makes it usable from a script. A request accepted after the watch begins is not picked up: a watch that grew as the queue did would never finish.
 

submitqueue/client/view.go

@@ -116,13 +116,19 @@ func (rw *Row) elapsed() string {
 	return fmt.Sprintf("%ds", int(end.Sub(rw.Submitted).Seconds()))
 }
 
-// stage is the path the request has taken, as the gateway recorded it. The
-// waiting marker covers the gap between acceptance and the first recorded
-// event, so an accepted request is never shown as though nothing happened.
+// stage is the path the request has taken, as the gateway recorded it.
+//
+// A one-shot listing reads the queue's receipts and does not fetch a history
+// per request, so it has the position each one holds but not how it got there.
+// That is worth showing on its own: a column of "…" says nothing about a queue
+// whose rows are mostly `speculating`.
 func (rw *Row) stage() string {
 	if len(rw.Trail) > 0 {
 		return strings.Join(rw.Trail, " → ")
 	}
+	if rw.Status != "" {
+		return rw.Status
+	}
 	if rw.SQID != "" {
 		return "…"
 	}
@@ -139,28 +145,99 @@ func Draw(rows []*Row, status string) {
 // digest reduces a request's recorded history to the trail worth showing, the
 // status it currently holds, and the error the latest event carried. A status
 // recorded more than once in a row is one step in the trail, not several.
+//
+// The history holds two kinds of entry. A status is a position the request
+// reached, and those are the trail's spine. An event is something that happened
+// while it sat at one — a build starting, a passed path waiting on a dependency
+// — and never changes the position, so each is shown against the status it
+// occurred under rather than as a step of its own:
+//
+//	batched → speculating [building ×2, built] → speculated
+//
+// Repeats are counted rather than listed. A batch runs one build per
+// speculation path, so a request that speculated widely records `building` many
+// times, and a trail that spelled each one out would say less than the count
+// does while pushing the rest of the row off the line.
 func digest(events []*pb.HistoryEvent) (trail []string, status, note string) {
 	if len(events) == 0 {
 		return nil, "", ""
 	}
+
+	// Events seen since the last status, in first-seen order with their counts,
+	// so they can be attached once the step they belong to is complete.
+	var pending []string
+	var last string
+	counts := make(map[string]int)
+
+	flush := func() {
+		if len(trail) == 0 || len(pending) == 0 {
+			pending, counts = nil, make(map[string]int)
+			return
+		}
+		trail[len(trail)-1] += " [" + strings.Join(annotate(pending, counts), ", ") + "]"
+		pending, counts = nil, make(map[string]int)
+	}
+
 	for _, e := range events {
-		if e == nil || e.Status == "" {
+		if e == nil {
 			continue
 		}
-		if len(trail) > 0 && trail[len(trail)-1] == e.Status {
+		if e.Status == "" {
+			if e.Event == "" {
+				continue
+			}
+			if counts[e.Event] == 0 {
+				pending = append(pending, e.Event)
+			}
+			counts[e.Event]++
 			continue
 		}
+		// A status repeated back-to-back is one step, but anything recorded
+		// against it in between still belongs to that step.
+		if e.Status == last {
+			continue
+		}
+		flush()
 		trail = append(trail, e.Status)
+		last = e.Status
 	}
+	flush()
+
 	if last := events[len(events)-1]; last != nil {
 		status, note = last.Status, last.LastError
 	}
-	if status == "" && len(trail) > 0 {
-		status = trail[len(trail)-1]
+	// The last entry may be an event, which leaves the request where it was.
+	if status == "" {
+		status = currentStatus(events)
 	}
 	return trail, status, note
 }
 
+// annotate renders each event with its count, dropping the count when it
+// happened once.
+func annotate(order []string, counts map[string]int) []string {
+	out := make([]string, 0, len(order))
+	for _, event := range order {
+		if counts[event] > 1 {
+			out = append(out, fmt.Sprintf("%s ×%d", event, counts[event]))
+			continue
+		}
+		out = append(out, event)
+	}
+	return out
+}
+
+// currentStatus is the last position the request reached, ignoring anything
+// recorded while it sat there.
+func currentStatus(events []*pb.HistoryEvent) string {
+	for i := len(events) - 1; i >= 0; i-- {
+		if e := events[i]; e != nil && e.Status != "" {
+			return e.Status
+		}
+	}
+	return ""
+}
+
 // outcome is the one-line verdict shown under the finished table.
 func outcome(rows []*Row) string {
 	landed := 0

submitqueue/client/view_test.go

@@ -81,11 +81,80 @@ func TestDigest(t *testing.T) {
 			wantNote:   "merge conflict",
 		},
 		{
-			name:       "events without a status do not become steps",
+			name:       "entries carrying neither a status nor an event are ignored",
 			events:     []*pb.HistoryEvent{{Status: ""}, {Status: "accepted"}, {Status: ""}},
 			wantTrail:  []string{"accepted"},
 			wantStatus: "accepted",
 		},
+		{
+			// An event is something that happened while the request sat at a
+			// position, so it belongs to that step rather than being one.
+			name: "an event is shown against the status it happened under",
+			events: []*pb.HistoryEvent{
+				{Status: "batched"},
+				{Status: "speculating"},
+				{Event: "building"},
+				{Event: "built"},
+				{Status: "speculated"},
+			},
+			wantTrail:  []string{"batched", "speculating [building, built]", "speculated"},
+			wantStatus: "speculated",
+		},
+		{
+			// One build per speculation path, so a request that speculated
+			// widely records this many times over.
+			name: "repeats are counted rather than listed",
+			events: []*pb.HistoryEvent{
+				{Status: "speculating"},
+				{Event: "building"}, {Event: "building"}, {Event: "building"},
+				{Event: "built"},
+			},
+			wantTrail:  []string{"speculating [building ×3, built]"},
+			wantStatus: "speculating",
+		},
+		{
+			name: "an event does not move the request off its status",
+			events: []*pb.HistoryEvent{
+				{Status: "speculating"}, {Event: "waiting"},
+			},
+			wantTrail:  []string{"speculating [waiting]"},
+			wantStatus: "speculating",
+		},
+		{
+			name: "each status collects only the events recorded under it",
+			events: []*pb.HistoryEvent{
+				{Status: "speculating"}, {Event: "building"},
+				{Status: "speculated"}, {Event: "invalidated"},
+				{Status: "speculating"}, {Event: "building"}, {Event: "built"},
+			},
+			wantTrail: []string{
+				"speculating [building]", "speculated [invalidated]", "speculating [building, built]",
+			},
+			wantStatus: "speculating",
+		},
+		{
+			name: "a status repeated around its own events is still one step",
+			events: []*pb.HistoryEvent{
+				{Status: "speculating"}, {Event: "building"}, {Status: "speculating"}, {Event: "built"},
+			},
+			wantTrail:  []string{"speculating [building, built]"},
+			wantStatus: "speculating",
+		},
+		{
+			name:       "an event before any status has nothing to attach to",
+			events:     []*pb.HistoryEvent{{Event: "building"}, {Status: "accepted"}},
+			wantTrail:  []string{"accepted"},
+			wantStatus: "accepted",
+		},
+		{
+			name: "an error carried by an event is still reported",
+			events: []*pb.HistoryEvent{
+				{Status: "speculating"}, {Event: "building", LastError: "runner unreachable"},
+			},
+			wantTrail:  []string{"speculating [building]"},
+			wantStatus: "speculating",
+			wantNote:   "runner unreachable",
+		},
 	}
 
 	for _, tt := range tests {
@@ -165,6 +234,23 @@ func TestRowStage(t *testing.T) {
 			row:  Row{SQID: "demo-queue/17", Trail: []string{"accepted", "started", "landed"}},
 			want: "accepted → started → landed",
 		},
+		{
+			// A listing reads receipts rather than histories, so it knows where
+			// a request is without knowing how it got there. That still beats
+			// a column of nothing.
+			name: "the position it holds, when the trail was never fetched",
+			row:  Row{SQID: "demo-queue/17", Status: "speculating"},
+			want: "speculating",
+		},
+		{
+			name: "a fetched trail is preferred over the bare position",
+			row: Row{
+				SQID:   "demo-queue/17",
+				Status: "landed",
+				Trail:  []string{"accepted", "landed"},
+			},
+			want: "accepted → landed",
+		},
 	}
 
 	for _, tt := range tests {