@@ -51,13 +51,22 @@ func (in *interactiveInput) commandAsync(fn func(context.Context) (string, error
 		defer cancel()
 		msg, err := fn(ctx)
 		if err != nil {
-			in.note(err.Error())
+			in.noteErr(err.Error())
 			return
 		}
 		in.note(msg)
 	}()
 }
 
+// noteErr is note for TROUBLE: same slot, same retirement, red rather than
+// gray. The split is here because this is the one place that knows which it
+// was -- the verb returned an error or it did not.
+func (in *interactiveInput) noteErr(msg string) {
+	in.mu.Lock()
+	in.lt.tr.setCommandNoteAt(msg, alertError)
+	in.mu.Unlock()
+}
+
 // note writes one line into the pager's status row, under the render lock.
 func (in *interactiveInput) note(msg string) {
 	in.mu.Lock()
 
@@ -104,25 +104,26 @@ func (d drawerID) face() drawerFace {
 // a keyMode from what is on screen.
 func (d drawerID) keys() keyMode { return d.face().keys }
 
-// token is what the pit contributes to the left of the status bar: GLYPH AND
-// NAME, always, because that is what the design draws --
+// token is what the pit contributes to the left of the status bar: THE GLYPH
+// ALONE, and the name only under `m`.
 //
-//	𝄚 queue · ✓ · 123abc · test                      9.8k/1.0m (1.0%)
+//	𝄚 · ✓ · 123abc · test                            9.8k/1.0m (1.0%)   (default)
+//	𝄚 queue · done ✓ · 123abc · test · …             (with `m`)
 //
-// It is not a verbose extra. The name is how you know which pit you are in,
-// and hiding it behind a toggle made the succinct bar say only "𝄚", which
-// answers the question for someone who has already memorised the glyphs and
-// for nobody else. Empty for the pits with nothing to announce, so the row
-// then begins with the state.
-func (d drawerID) token() string {
+// This bar is read by someone who knows the glyphs. Verbose is for the reader
+// who does not, and spelling every symbol out by default spends the row's
+// width teaching a lesson its only reader has already had. (I had this right,
+// then "corrected" it against a sketch that was showing the verbose form.)
+func (d drawerID) token(verbose bool) string {
 	f := d.face()
-	if f.glyph == "" {
+	switch {
+	case f.glyph == "":
 		return ""
-	}
-	if f.name == "" {
+	case verbose && f.name != "":
+		return f.glyph + " " + f.name
+	default:
 		return f.glyph
 	}
-	return f.glyph + " " + f.name
 }
 
 // selectionGlyph marks the row under the cursor. It is PER DRAWER, not one
 
@@ -204,14 +204,32 @@ func (p *picker) remove() {
 
 // lines draws the window: the visible rows, the selection marker, and an
 // honest count of what is out of view on either side.
+// lines draws EXACTLY h rows, always. The markers are part of the budget, not
+// an addition to it: they appear and vanish as you scroll, and a pit whose
+// height moved by a row every time you crossed the top of the list made the
+// transcript above it jump by a row too. A window that changes size while you
+// read it is the thing this component exists to stop.
 func (p *picker) lines(id drawerID, w, h int) []string {
-	p.height = clampInt(h, 1, pickerRows)
+	budget := clampInt(h, 1, pickerRows)
+	// Reserve the marker rows FIRST, out of the same budget.
+	markAbove, markBelow := 0, 0
+	if len(p.rows) > budget {
+		// A list that does not fit shows at least one marker; which one
+		// depends on where the window sits, so both are reserved and the
+		// visible count is fixed either way.
+		markAbove, markBelow = 1, 1
+	}
+	p.height = max(budget-markAbove-markBelow, 1)
 	p.top = clampInt(p.top, 0, p.maxTop())
 	end := min(p.top+p.window(), len(p.rows))
 
-	out := make([]string, 0, p.window()+2)
-	if p.top > 0 {
-		out = append(out, drawerGray(clipToWidth("  "+AndMore(p.top, "above"), w)))
+	out := make([]string, 0, budget)
+	if markAbove > 0 {
+		if p.top > 0 {
+			out = append(out, drawerGray(clipToWidth("  "+AndMore(p.top, "above"), w)))
+		} else {
+			out = append(out, "")
+		}
 	}
 	mark := id.selectionGlyph()
 	for i := p.top; i < end; i++ {
@@ -226,8 +244,12 @@ func (p *picker) lines(id drawerID, w, h int) []string {
 		}
 		out = append(out, row)
 	}
-	if rest := len(p.rows) - end; rest > 0 {
-		out = append(out, drawerGray(clipToWidth("  "+AndMore(rest, ""), w)))
+	if markBelow > 0 {
+		if rest := len(p.rows) - end; rest > 0 {
+			out = append(out, drawerGray(clipToWidth("  "+AndMore(rest, ""), w)))
+		} else {
+			out = append(out, "")
+		}
 	}
 	return out
 }
 
@@ -113,6 +113,12 @@ type sessionStatus struct {
 	lastAt time.Time
 	// model is shown under verbose only.
 	model string
+	// noticeLevel is what KIND of news the alert is. "sent" and "showing
+	// abc12345" are confirmations and wear the row's own gray; only trouble is
+	// red. Painting every alert red made the bar cry wolf on its own success
+	// messages -- and it is the same severity the notification ring will sort
+	// by, so it is one field rather than two ideas.
+	noticeLevel alertLevel
 	// noticeUntil is when the bar's alert retires; see retireAlert.
 	noticeUntil time.Time
 	// noticeTTL is how long a posted alert holds the slot. Zero: forever.
@@ -126,8 +132,18 @@ type sessionStatus struct {
 	notice string
 }
 
+// defaultNoticeTTL is how long an alert holds the bar's first slot. It is a
+// CONSTRUCTOR DEFAULT, not a config-only value, and that distinction is the
+// whole of a bug I shipped: setNoticeTTL existed, config.NoticeTTL existed,
+// and nothing called either -- so every alert was minted with a zero TTL,
+// which means "hold the slot until something displaces you", which means an
+// error sat in the bar until the next one arrived. Forever, in practice.
+//
+// A default that has to be installed by a caller is not a default.
+const defaultNoticeTTL = 10 * time.Second
+
 func newSessionStatus(figaroID string, startedAt time.Time) *sessionStatus {
-	return &sessionStatus{figaroID: figaroID, startedAt: startedAt}
+	return &sessionStatus{figaroID: figaroID, startedAt: startedAt, noticeTTL: defaultNoticeTTL}
 }
 
 // setNotice publishes (or clears, with "") the bar's alert: the newest thing
@@ -140,12 +156,33 @@ func newSessionStatus(figaroID string, startedAt time.Time) *sessionStatus {
 // dismissed: a bar item that must be acknowledged is a bar item that is still
 // there tomorrow. Retirement happens on the ticker (retireAlert), because a
 // clock cannot fire inside a pure renderer.
+// alertLevel sorts news by whether it is trouble.
+type alertLevel uint8
+
+const (
+	alertInfo  alertLevel = iota // a confirmation: gray, like the rest of the row
+	alertError                   // trouble: red, and eventually a notification
+)
+
+// setNoticeAt posts an alert with its level. setNotice is the confirmation
+// case, which is the common one.
+func (s *sessionStatus) setNoticeAt(text string, level alertLevel) {
+	s.setNotice(text)
+	if s == nil {
+		return
+	}
+	s.mu.Lock()
+	s.noticeLevel = level
+	s.mu.Unlock()
+}
+
 func (s *sessionStatus) setNotice(text string) {
 	if s == nil {
 		return
 	}
 	s.mu.Lock()
 	s.notice = strings.Join(strings.Fields(text), " ")
+	s.noticeLevel = alertInfo
 	switch {
 	case s.notice == "":
 		s.noticeUntil = time.Time{}
@@ -316,8 +353,9 @@ func (s *sessionStatus) panelLines() []string {
 	if state == "" {
 		state = "idle 𝄐"
 	}
+	// NO LEADING BLANK. The panel used to open with an empty row, which read as
+	// an extra newline under the rule above it.
 	rows := []string{
-		"",
 		"  aria      " + s.figaroID,
 		"  status    " + state,
 	}
 
@@ -52,8 +52,10 @@ func TestStatusNoticeIsRedAndLeftmost(t *testing.T) {
 	// routing it through the palette fixes.
 	defer term.SetColorMode(term.ColorAlways)()
 
+	// ONLY TROUBLE IS RED now, so this test posts trouble. A confirmation
+	// ("sent") wears the row's own gray -- see TestOnlyTroubleIsRed.
 	s := statusFixture("a perfectly ordinary mantra")
-	s.setNotice("error: overloaded")
+	s.setNoticeAt("error: overloaded", alertError)
 	line := row(s, 200)
 
 	// Through the palette, not a literal: the assertion asks the theme what a
 
@@ -32,7 +32,8 @@ type statusView struct {
 	// TRANSIENT and its expiry is evaluated by whoever builds this value --
 	// never here, or the pure renderer becomes a function of the wall clock
 	// and its goldens become flaky.
-	Alert string
+	Alert      string
+	AlertLevel alertLevel
 	// LastAt is when the conversation last moved. Verbose only, and absolute:
 	// a relative "3m ago" would be true only at the instant it was painted.
 	LastAt  time.Time
@@ -89,13 +90,21 @@ func (v statusView) render(w int) []string {
 // groups is the split: what is about the MODE and the conversation on the left,
 // what is a fact about the aria on the right.
 func (v statusView) groups() (left, right []string) {
-	// The alert leads, ahead of even the mode: trouble belongs where the eye
-	// lands first, and it is the only field that arrives without being asked
-	// for.
+	// The alert leads, ahead of even the pit: news belongs where the eye lands
+	// first, and it is the only field that arrives without being asked for.
+	//
+	// ONLY TROUBLE IS RED. "sent" is a confirmation and wears the row's own
+	// gray; painting every alert red made the bar shout its successes in the
+	// colour it reserves for failures, which is how a colour stops meaning
+	// anything.
 	if v.Alert != "" {
-		left = append(left, term.NoticeInDim(v.Alert))
+		if v.AlertLevel == alertError {
+			left = append(left, term.NoticeInDim(v.Alert))
+		} else {
+			left = append(left, v.Alert)
+		}
 	}
-	if tok := v.Drawer.token(); tok != "" {
+	if tok := v.Drawer.token(v.Verbose); tok != "" {
 		left = append(left, tok)
 	}
 	if st := v.stateToken(); st != "" {
@@ -154,17 +163,25 @@ func (s *sessionStatus) viewOf(drawer drawerID, verbose bool, now time.Time) sta
 	if s == nil {
 		return statusView{}
 	}
+	// THE TICKER IS NOT THE ONLY CLOCK. It runs while something animates; an
+	// idle pager animates nothing, so an alert posted after the turn ended
+	// would have waited for the next keystroke to notice it had expired. Every
+	// build of the view checks too -- it is one comparison, it happens exactly
+	// where the wall clock is already being read, and it makes "the alert
+	// retires" true rather than usually true.
+	s.retireAlert(now)
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	v := statusView{
-		Drawer:  drawer,
-		State:   s.turn,
-		Tick:    s.tick,
-		Aria:    s.figaroID,
-		Mantra:  s.metrics.Mantra,
-		Alert:   s.notice,
-		LastAt:  s.lastAt,
-		Verbose: verbose,
+		Drawer:     drawer,
+		State:      s.turn,
+		Tick:       s.tick,
+		Aria:       s.figaroID,
+		Mantra:     s.metrics.Mantra,
+		Alert:      s.notice,
+		AlertLevel: s.noticeLevel,
+		LastAt:     s.lastAt,
+		Verbose:    verbose,
 	}
 	if ctx := formatContextUsage(s.metrics.ContextTokens, s.metrics.ContextLimit, s.metrics.ContextExact); ctx != "-" {
 		v.Ctx = ctx
 
@@ -4,6 +4,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/jack-work/figaro/internal/term"
 )
 
 // ---------------------------------------------------------------------------
@@ -42,12 +44,11 @@ func TestStatusViewGoldens(t *testing.T) {
 			want: []string{"✓ · 123abc · test                                               9.8k/1.0m (1.0%)"},
 		},
 		{
-			// THE NAME IS NOT A VERBOSE EXTRA. The design draws "𝄚 queue",
-			// always: the glyph alone answers the question only for someone
-			// who has already memorised the glyphs.
-			name: "a pit leads with its glyph AND its name", width: 80,
+			// THE NAME IS A VERBOSE EXTRA. This bar is read by someone who
+			// knows the glyphs; the word is for the reader who does not.
+			name: "a pit leads with its glyph alone", width: 80,
 			view: func(v statusView) statusView { v.Drawer = drawerQueue; return v },
-			want: []string{"𝄚 queue · ✓ · 123abc · test                                     9.8k/1.0m (1.0%)"},
+			want: []string{"𝄚 · ✓ · 123abc · test                                           9.8k/1.0m (1.0%)"},
 		},
 		{
 			name: "verbose names the drawer and the state", width: 96,
@@ -171,3 +172,87 @@ func TestVerboseCarriesTheLastInteraction(t *testing.T) {
 		t.Fatalf("the default bar carries a datetime: %q", row)
 	}
 }
+
+// TestOnlyTroubleIsRed: a confirmation wears the row's own gray. Painting
+// every alert red made the bar shout "sent" in the colour it keeps for
+// failures, which is how a colour stops meaning anything.
+func TestOnlyTroubleIsRed(t *testing.T) {
+	restore := term.SetColorMode(term.ColorAlways)
+	defer restore()
+
+	v := barFixture()
+	v.Alert = "sent"
+	info := strings.Join(v.render(100), "")
+	if !strings.Contains(info, "sent") {
+		t.Fatalf("the confirmation is missing: %q", info)
+	}
+	if strings.Contains(info, term.NoticeInDim("sent")) {
+		t.Fatalf("a confirmation was painted as trouble: %q", info)
+	}
+
+	v.AlertLevel = alertError
+	bad := strings.Join(v.render(100), "")
+	if !strings.Contains(bad, term.NoticeInDim("sent")) {
+		t.Fatalf("trouble was not painted red: %q", bad)
+	}
+}
+
+// TestAlertLevelResetsOnEveryPost: a red error must not tint the confirmation
+// that follows it. setNotice is the confirmation door and clears the level.
+func TestAlertLevelResetsOnEveryPost(t *testing.T) {
+	s := newSessionStatus("aria1234", time.Now())
+	s.setNoticeAt("boom", alertError)
+	if v := s.viewOf(drawerNothing, false, time.Now()); v.AlertLevel != alertError {
+		t.Fatal("the error did not take")
+	}
+	s.setNotice("sent")
+	if v := s.viewOf(drawerNothing, false, time.Now()); v.AlertLevel != alertInfo {
+		t.Fatal("a confirmation inherited the previous error's colour")
+	}
+}
+
+// TestAlertRetiresOnItsOwn is the test that was missing, and its absence is
+// why an alert sat in the bar forever: setNoticeTTL existed, cli.notice_ttl
+// existed, and NOTHING CALLED EITHER -- so every alert was born with a zero
+// TTL, which means "hold the slot until displaced".
+//
+// It drives the clock rather than sleeping: the expiry is a comparison against
+// a time the caller passes, precisely so this can be tested in microseconds.
+func TestAlertRetiresOnItsOwn(t *testing.T) {
+	s := newSessionStatus("aria1234", time.Now())
+	if s.noticeTTL <= 0 {
+		t.Fatal("a fresh session has no notice TTL; a default a caller must install is not a default")
+	}
+	s.setNotice("sent")
+
+	now := time.Now()
+	if v := s.viewOf(drawerNothing, false, now); v.Alert != "sent" {
+		t.Fatalf("the alert did not post: %q", v.Alert)
+	}
+	// Still there a moment later.
+	if v := s.viewOf(drawerNothing, false, now.Add(time.Second)); v.Alert != "sent" {
+		t.Fatalf("the alert retired early: %q", v.Alert)
+	}
+	// And gone once its span is up, WITHOUT a keystroke or a tick: an idle
+	// pager animates nothing, so the view build is the backstop.
+	if v := s.viewOf(drawerNothing, false, now.Add(defaultNoticeTTL+time.Second)); v.Alert != "" {
+		t.Fatalf("the alert outlived its TTL: %q", v.Alert)
+	}
+}
+
+// TestNewerAlertDisplacesOlder: the other way an alert leaves. A burst of
+// them -- ten `:send`s in a row -- must show the newest, not a stack.
+func TestNewerAlertDisplacesOlder(t *testing.T) {
+	s := newSessionStatus("aria1234", time.Now())
+	for i := 0; i < 10; i++ {
+		s.setNotice("sent")
+	}
+	s.setNotice("showing abc12345")
+	v := s.viewOf(drawerNothing, false, time.Now())
+	if v.Alert != "showing abc12345" {
+		t.Fatalf("the newest alert did not win: %q", v.Alert)
+	}
+	if strings.Count(v.Alert, "sent") != 0 {
+		t.Fatalf("alerts stacked instead of displacing: %q", v.Alert)
+	}
+}