cli: Enter spells a notification out, and the pit paints its level

Two polish passes on the notifications pit, both asked for after living
with it (Gluck, 2026-09-30).

ENTER. It used to print the full date and the source under a row, which
is furniture: the row already carries the time and the aria. It now
spells the notification OUT, the way the state pit's Enter opens a value
(formView.Activate -> openBranch): the whole text, wrapped to the pane,
every line selectable and yanking the whole, so a long single line can be
read rather than clipped at the pane edge. Bounded at 200 lines, as an
opened form value is at 500, with the same "y yanks all of it".

THE LEVEL IS A COLOUR, not only a glyph. It cannot ride in the row's
text, which goes through pitText and loses every escape, so a row carries
a tone (pitRow.tone) and the picker paints it: the palette's own red for
an error, its yellow for a warning, nothing for info. Over the selection
wash each is the same colour lifted (term.NoticeOnWash), because
autumnRed on mid-grey reads at 1.9:1. A pit that sets no tone renders
byte for byte as it did before, which is asserted rather than assumed.

Tests, red first: two view cases (the whole text wrapped at width 60, and
no date or source anywhere in it) and one picker case (wash plus lifted
red on the selected row, the palette's red on an unselected one, an
untoned row unchanged byte for byte, no escape at all with colour off).
scripts/notifications-pty.sh grows four checks, each of which fails on
654d999 and passes here, plus the premise they rest on: the row really
cannot hold the text.

Author: gluck

internal/cli/keymap.go

@@ -830,7 +830,7 @@ var helpRows = []helpRow{
 	{helpSelectExtend, "^N/^P + Shift", "travel between questions (Alt+^N/^P extends a selection)"},
 	{helpExpand, "Enter", "open tool bodies and form deltas within the selection"},
 	{helpToolBody, "e", "open the tool bodies within the selection"},
-	{helpPitEnter, "(in a list) Enter", "the row's own action: open a form value, attend an aria"},
+	{helpPitEnter, "(in a list) Enter", "the row's own action: open a form value or a notification, attend an aria"},
 	{helpVisualSelect, "(in v) Enter", "select the node under the cursor (then e expands it)"},
 	{helpVisualAttend, "(in v) a", "attend the highlighted id, or the word under the cursor; a path opens in your editor"},
 	{helpEscape, "Esc", "clear selection / close panel"},

internal/cli/keymap_test.go

@@ -351,7 +351,7 @@ func TestHelpBody_MatchesTheOldHandWrittenPanel(t *testing.T) {
 		"  ^N/^P + Shift       travel between questions (Alt+^N/^P extends a selection)",
 		"  Enter               open tool bodies and form deltas within the selection",
 		"  e                   open the tool bodies within the selection",
-		"  (in a list) Enter   the row's own action: open a form value, attend an aria",
+		"  (in a list) Enter   the row's own action: open a form value or a notification, attend an aria",
 		"  (in v) Enter        select the node under the cursor (then e expands it)",
 		"  (in v) a            attend the highlighted id, or the word under the cursor; a path opens in your editor",
 		"  Esc                 clear selection / close panel",

internal/cli/notifications.go

@@ -210,26 +210,41 @@ type notificationsView struct {
 
 func (v *notificationsView) Close() { v.closed = true }
 
-// Items is one row per notification, newest first, with an expanded row's
-// detail beneath it as unselectable lines.
+// Items is one row per notification, newest first, with an opened row's whole
+// text beneath it.
 func (v *notificationsView) Items(width int) []pitRow {
 	v.store.markRead()
 	items := v.store.newestFirst()
+	if width <= 0 {
+		width = 80
+	}
 	var rows []pitRow
 	for _, n := range items {
 		if !v.filter.keeps(n.level) {
 			continue
 		}
 		id := strconv.FormatUint(n.seq, 10)
+		yank := n.yank()
 		rows = append(rows, pitRow{
 			id:   id,
-			yank: n.yank(),
+			yank: yank,
 			text: n.row(),
+			tone: n.level.tone(),
 		})
-		if v.expanded[id] {
-			for _, l := range n.expansion() {
-				rows = append(rows, staticRow("      "+l))
-			}
+		if !v.expanded[id] {
+			continue
+		}
+		// AS THE STATE PIT OPENS A VALUE: the whole thing, wrapped to the
+		// pane, each line selectable so a reader can walk a long one, and
+		// every one of them yanks the whole. The indent is the row's
+		// continuation, and the 2 is the picker's own selection column.
+		for i, l := range n.fullLines(width - len(notificationIndent) - 2) {
+			rows = append(rows, pitRow{
+				text: notificationIndent + l,
+				yank: yank,
+				id:   fmt.Sprintf("%s\x00%d", id, i),
+				tone: n.level.tone(),
+			})
 		}
 	}
 	if len(rows) == 0 {
@@ -242,11 +257,18 @@ func (v *notificationsView) Items(width int) []pitRow {
 	return rows
 }
 
-// Activate is Enter, the pit's own action: expand the row or fold it back.
+// notificationIndent is what an opened line is set in by, so it reads as the
+// row's continuation and not as another notification.
+const notificationIndent = "      "
+
+// Activate is Enter, the pit's own action: spell the notification out, or fold
+// it back. A line of an opened one addresses the notification it belongs to,
+// so Enter there folds it, as it does over a form value.
 func (v *notificationsView) Activate(id string) {
 	if v.expanded == nil {
 		v.expanded = map[string]bool{}
 	}
+	id = valuePath(id)
 	v.expanded[id] = !v.expanded[id]
 }
 
@@ -263,8 +285,9 @@ func (v *notificationsView) Key(b byte) bool {
 }
 
 // AriaOf is what `a` attends from a row: the aria it concerns, when it
-// concerns one.
+// concerns one. A line of an opened notification answers for the whole.
 func (v *notificationsView) AriaOf(id string) string {
+	id = valuePath(id)
 	for _, n := range v.store.newestFirst() {
 		if strconv.FormatUint(n.seq, 10) == id {
 			// A source is "cli" or an aria id, by construction; the id check
@@ -290,6 +313,19 @@ func (l alertLevel) glyph() string {
 	return "·"
 }
 
+// tone is the level as a COLOUR: the pit paints a row red for trouble and
+// yellow for a warning, the same two the bar's unread mark wears. A glyph
+// alone did not find an error in a list of forty.
+func (l alertLevel) tone() pitTone {
+	switch l {
+	case alertError:
+		return toneError
+	case alertWarn:
+		return toneWarn
+	}
+	return toneNone
+}
+
 // row is the line the pit draws: when, how bad, about what, what, how often.
 func (n notification) row() string {
 	src := n.source
@@ -306,29 +342,36 @@ func (n notification) row() string {
 	return s
 }
 
-// expansion is what Enter shows under a row: what the row could not hold.
-// The whole text when there was more than a line (a one-liner is already all
-// on the row, and repeating it said nothing), then the full date and where it
-// came from, and how often when it has repeated.
-func (n notification) expansion() []string {
-	var out []string
-	if n.detail != "" {
-		out = append(out, strings.Split(n.detail, "\n")...)
+// fullLines is what Enter shows: the whole of it, wrapped to the pane, as the
+// state pit's Enter spells out a value. The detail when the message had more
+// than a line, else the row's own single line, which the pane clipped.
+//
+// It used to show the full date and the source instead, which is furniture:
+// the row already carries the time and the aria, and what a reader wants from
+// a clipped error is the rest of the error.
+func (n notification) fullLines(width int) []string {
+	body := n.detail
+	if body == "" {
+		body = n.text
 	}
-	src := n.source
-	if src == "" || src == "cli" {
-		src = "this pager"
+	var out []string
+	for _, l := range strings.Split(body, "\n") {
+		// Wrapped, never clipped, and stripped at the source as well as at the
+		// paint: a provider's refusal can carry anything. The yank is
+		// untouched.
+		out = append(out, wrapPlain(pitText(strings.TrimRight(l, "\r")), max(width, 20))...)
 	}
-	when := n.last.Format("Mon 2006-01-02 15:04:05")
-	switch {
-	case n.count > 1:
-		out = append(out, fmt.Sprintf("%s, from %s: %d times since %s", when, src, n.count, n.at.Format("15:04:05")))
-	default:
-		out = append(out, fmt.Sprintf("%s, from %s", when, src))
+	if len(out) > notificationLinesMax {
+		out = append(out[:notificationLinesMax:notificationLinesMax],
+			AndMore(len(out)-notificationLinesMax, "lines · y yanks all of it"))
 	}
 	return out
 }
 
+// notificationLinesMax bounds an opened one. A message is a line or a
+// paragraph; anything past this is a log, and the yank is the way to read it.
+const notificationLinesMax = 200
+
 // yank is what y copies: the whole of it, with where it came from.
 func (n notification) yank() string {
 	body := n.text

internal/cli/notifications_test.go

@@ -130,19 +130,81 @@ func TestNotificationsView(t *testing.T) {
 		}
 	})
 
-	t.Run("Enter expands a row to its whole text and folds it back", func(t *testing.T) {
+	t.Run("Enter spells out the whole text and folds it back", func(t *testing.T) {
 		id := v.Items(80)[0].id
 		v.Activate(id)
 		rows := v.Items(80)
-		if len(rows) < 4 || !strings.Contains(rows[1].text+rows[2].text, "provider said: overloaded") || rows[1].selectable() {
-			t.Fatalf("the detail follows its row, unselectable: %+v", rows)
+		if len(rows) < 4 || !strings.Contains(rows[1].text+rows[2].text, "provider said: overloaded") {
+			t.Fatalf("the whole text follows its row: %+v", rows)
+		}
+		// The state pit's Enter opens a value and nothing else; this one is the
+		// same gesture. The date and the source were what it used to show, and
+		// the row already carries the time and the aria.
+		for _, r := range rows[1:3] {
+			if strings.Contains(r.text, "from this pager") || strings.Contains(r.text, "3b7aff0a,") {
+				t.Fatalf("Enter is showing furniture instead of the text: %q", r.text)
+			}
+		}
+		// A value row is selectable, as an opened value's rows are in the form
+		// pit: a reader walks a long one, and every row yanks the whole thing.
+		if !rows[1].selectable() || rows[1].yank != rows[0].yank {
+			t.Fatalf("an opened line must be walkable and yank the whole: %+v", rows[1])
+		}
+		// Enter on one of those rows folds the notification it belongs to.
+		v.Activate(rows[1].id)
+		if len(v.Items(80)) != 3 {
+			t.Fatal("Enter on an opened line did not fold it")
+		}
+		v.Activate(id)
+		if len(v.Items(80)) <= 3 {
+			t.Fatal("Enter did not open it again")
 		}
 		v.Activate(id)
 		if len(v.Items(80)) != 3 {
 			t.Fatal("a second Enter folds it")
 		}
 	})
 
+	// A LONG SINGLE LINE IS WHY THIS EXISTS: the row clips at the pane edge,
+	// and the only way to read the rest was to yank it into a pager.
+	t.Run("Enter wraps a long single line instead of clipping it", func(t *testing.T) {
+		s := newNotificationStore()
+		long := "turn failed: " + strings.Repeat("provider said no ", 20)
+		s.post(alertError, "cli", long)
+		v := &notificationsView{store: s}
+		id := v.Items(60)[0].id
+		v.Activate(id)
+		rows := v.Items(60)
+		if len(rows) < 5 {
+			t.Fatalf("a 350-column line opened into %d rows at width 60: %+v", len(rows), rows)
+		}
+		var body string
+		for _, r := range rows[1:] {
+			if w := displayWidth(r.text); w > 60 {
+				t.Fatalf("an opened row is %d columns wide: %q", w, r.text)
+			}
+			body += strings.TrimSpace(r.text) + " "
+		}
+		if want := strings.Join(strings.Fields(long), " "); !strings.Contains(strings.Join(strings.Fields(body), " "), want) {
+			t.Fatalf("the opened rows do not hold the whole line:\n got %q\nwant %q", body, want)
+		}
+	})
+
+	// THE LEVEL IS A COLOUR, not only a glyph: the picker paints the row, so
+	// the view says which tone it wears and smuggles no escape into the text.
+	t.Run("errors are red and warnings yellow, info plain", func(t *testing.T) {
+		rows := v.Items(80)
+		want := []pitTone{toneError, toneWarn, toneNone}
+		for i, w := range want {
+			if rows[i].tone != w {
+				t.Fatalf("row %d (%q) wears tone %v, want %v", i, rows[i].text, rows[i].tone, w)
+			}
+			if strings.ContainsRune(rows[i].text, 0x1b) {
+				t.Fatalf("row %d smuggles an escape into its text: %q", i, rows[i].text)
+			}
+		}
+	})
+
 	t.Run("a is attend: the row's aria, and nothing for a row that has none", func(t *testing.T) {
 		rows := v.Items(80)
 		if got := v.AriaOf(rows[0].id); got != "3b7aff0a" {

internal/cli/picker.go

@@ -357,10 +357,10 @@ func (p *picker) lines(id pitID, w, h int) []string {
 		}
 		row := clipToWidth(text, w)
 		if i == p.cursor {
-			out = append(out, pitSelected(row))
+			out = append(out, pitSelected(row, p.rows[i].tone))
 			continue
 		}
-		out = append(out, row)
+		out = append(out, p.rows[i].tone.paint(row))
 	}
 	if markBelow {
 		out = append(out, pitGray(clipToWidth("  "+AndMore(len(p.rows)-end, ""), w)))

internal/cli/pit.go

@@ -48,8 +48,23 @@ type pitRow struct {
 	// It goes through the same gate as text, and is drawn at full strength
 	// on the selected row, where dim on a wash would not read.
 	note string
+	// tone is the row's level, painted by the picker. It cannot ride in the
+	// text: every row goes through pitText, which strips escapes, and it must
+	// not, or a form value holding an SGR would repaint the pane. The zero
+	// value is no colour, so a pit that never heard of tones is untouched.
+	tone pitTone
 }
 
+// pitTone is what a row's level looks like. Three, because a message has three
+// (see alertLevel): trouble, a warning, and everything else.
+type pitTone uint8
+
+const (
+	toneNone pitTone = iota
+	toneError
+	toneWarn
+)
+
 // staticRow is drawn but never selected. (Not "chromeRow": that name is taken
 // in transcript_mouse_test.go for a different idea.)
 func staticRow(text string) pitRow { return pitRow{text: text} }
@@ -253,11 +268,47 @@ func pitGray(s string) string { return term.Label(s) }
 
 // pitSelected is the one row in a pit drawn at full strength: it is what every
 // verb acts on, so it must be read first. Dim text on a dark wash was not.
-func pitSelected(s string) string {
+// A toned row keeps its colour over the wash: the selection says where you
+// are standing, and the tone says what you are standing on.
+func pitSelected(s string, tone pitTone) string {
 	if !term.Enabled() {
 		return s
 	}
-	return "\x1b[48;5;240m\x1b[38;5;255m" + s + "\x1b[39m\x1b[49m"
+	fg := "\x1b[38;5;255m"
+	if body := tone.washBody(); body != "" {
+		fg = body
+	}
+	return "\x1b[48;5;240m" + fg + s + "\x1b[39m\x1b[49m"
+}
+
+// paint colours a whole row and hands the pane back as it found it. An untoned
+// row is returned untouched, so a pit that sets no tone renders byte for byte
+// as it did before there were any.
+func (t pitTone) paint(s string) string {
+	body := ""
+	switch t {
+	case toneError:
+		body = term.NoticeBody()
+	case toneWarn:
+		body = term.CautionBody()
+	}
+	if body == "" {
+		return s
+	}
+	return body + s + "\x1b[0m"
+}
+
+// washBody is the tone over the selection wash: the same colour, lifted,
+// because the palette's own red on a mid-grey wash is 1.9:1 and reads as mud.
+// The wash is the caller's.
+func (t pitTone) washBody() string {
+	switch t {
+	case toneError:
+		return term.NoticeOnWash()
+	case toneWarn:
+		return term.CautionOnWash()
+	}
+	return ""
 }
 
 // pitText is the gate every pit row passes through: THE PIT PAINTS TEXT, NEVER