@@ -0,0 +1,107 @@
+package cli
+
+// WHAT IS OPEN, and the one place that answers it.
+//
+// The bottom of the pager has two questions about the same fact: what does the
+// KEYBOARD do (a keyMode, see keymap.go), and what does the READER see (a
+// glyph and a name in the status bar). Both used to be derived, separately,
+// from `inSearch`/`inJump`/`drawer.kind` — three booleans consulted by four
+// files, which for one frame could disagree.
+//
+// They are different axes and they stay two types, because `help`, `status` and
+// `queue` are three different things on screen while sharing modePanel. But
+// they are NOT independent: the drawer identity is the SOURCE and the keyMode
+// is DERIVED from it. That is what makes "one owner" true rather than
+// aspirational. See plans/status-bar-and-modes.md §2.
+
+// drawerID names a drawer. It is the string the drawer already carried —
+// `showList("queue", …)` — promoted to a type so the table below can be
+// exhaustive and a typo is a compile error rather than a silently nameless
+// drawer.
+type drawerID string
+
+const (
+	drawerNothing       drawerID = ""
+	drawerQueue         drawerID = "queue"
+	drawerNotifications drawerID = "notifications"
+	drawerCommand       drawerID = "command"
+	drawerSearch        drawerID = "search"
+	drawerHelp          drawerID = "help"
+	drawerStatus        drawerID = "status"
+	drawerNote          drawerID = "message"
+	drawerOutput        drawerID = "output"
+)
+
+// drawerFace is how a drawer presents itself: the glyph that leads the status
+// bar, the word beside it under verbose, and the glyph marking its selected
+// row. An empty glyph is not an oversight — see the table.
+type drawerFace struct {
+	glyph     string
+	name      string
+	selection string
+	keys      keyMode
+}
+
+// drawerFaces is THE table. Every drawer has a row, including the ones with
+// nothing to show: if this is the source of `keys()`, then a message and a
+// hosted live view are identities too. They simply contribute no token to the
+// bar, which is what an empty glyph means.
+//
+// The glyphs are Gluck's, and they are musical on purpose: the queue is a
+// staff (𝄚), notifications are a clef (𝄞), a selected row is a note (♭ / ♩).
+// Search is ⌕ (U+2315) and not 🔍 — the bar is width-sensitive and every other
+// glyph here is single-width, while the emoji magnifier is double-width and
+// font-dependent, which would make the bar's layout a property of the reader's
+// terminal rather than of the program.
+var drawerFaces = map[drawerID]drawerFace{
+	drawerNothing:       {"", "", "", modeTranscript},
+	drawerQueue:         {"𝄚", "queue", "♭", modePanel},
+	drawerNotifications: {"𝄞", "notifications", "♩", modePanel},
+	drawerCommand:       {"∴", "command", "", modeJump},
+	drawerSearch:        {"⌕", "search", "", modeSearch},
+	drawerHelp:          {"?", "help", "", modePanel},
+	drawerStatus:        {"!", "status", "", modePanel},
+	drawerNote:          {"", "", "", modePanel},
+	drawerOutput:        {"", "", "♭", modePanel},
+}
+
+// face is the drawer's presentation, or the empty face for one nobody has
+// named. A missing row is deliberately not a panic: an unnamed drawer draws no
+// token and takes modePanel, which is what the pager did before this table
+// existed and is a safe thing for a new drawer to do before it is described.
+func (d drawerID) face() drawerFace {
+	if f, ok := drawerFaces[d]; ok {
+		return f
+	}
+	return drawerFace{keys: modePanel}
+}
+
+// keys is the KEYBOARD half, derived. Nothing else in the program may compute
+// a keyMode from what is on screen.
+func (d drawerID) keys() keyMode { return d.face().keys }
+
+// token is what the drawer contributes to the left of the status bar: its
+// glyph, plus its name under verbose. Empty for the drawers that have nothing
+// to announce, so the row then begins with the state.
+func (d drawerID) token(verbose bool) string {
+	f := d.face()
+	switch {
+	case f.glyph == "":
+		return ""
+	case verbose && f.name != "":
+		return f.glyph + " " + f.name
+	default:
+		return f.glyph
+	}
+}
+
+// selectionGlyph marks the row under the cursor. It is PER DRAWER, not one
+// global marker: the spec gives the queue a flat and notifications a quarter
+// note, and they are read in different postures — a queue row is a thing you
+// are about to act on, a notification is a thing you are reading.
+func (d drawerID) selectionGlyph() string {
+	if g := d.face().selection; g != "" {
+		return g
+	}
+	return "▸"
+}
@@ -106,6 +106,13 @@ type sessionStatus struct {
 	// verbose is the BAR's verbosity (^V), not the tool-output toggle (^O).
 	// Seeded from config; see plans/status-bar-and-modes.md §5.
 	verbose bool
+	// lastAt is when this conversation last MOVED, in either direction --
+	// not when the session started, and not when the user last typed. An
+	// agent working alone for an hour is a conversation that is moving, and a
+	// bar that called that stale would be wrong in the case you are checking.
+	lastAt time.Time
+	// model is shown under verbose only.
+	model string
 	// notice is trouble the user must see, an error reason, an interrupt
 	// notice: carried IN the frame buffer instead of being written straight
 	// to the terminal. While the pager is up there is no scrollback to write
@@ -147,6 +154,32 @@ func (s *sessionStatus) beginTurn() {
 	}
 	s.mu.Lock()
 	s.turn = turnStatusThinking
+	s.lastAt = time.Now()
+	s.mu.Unlock()
+}
+
+// touch records that the conversation MOVED. Called on every frame that
+// carries content, in either direction: what the bar answers with it is "is
+// this stale", and a turn that is producing output is not stale even though
+// nobody has typed for an hour.
+func (s *sessionStatus) touch(at time.Time) {
+	if s == nil || at.IsZero() {
+		return
+	}
+	s.mu.Lock()
+	if at.After(s.lastAt) {
+		s.lastAt = at
+	}
+	s.mu.Unlock()
+}
+
+// setModel records the model for the verbose bar.
+func (s *sessionStatus) setModel(m string) {
+	if s == nil {
+		return
+	}
+	s.mu.Lock()
+	s.model = m
 	s.mu.Unlock()
 }
 
@@ -159,6 +192,7 @@ func (s *sessionStatus) finishTurn(reason string) {
 		return
 	}
 	s.mu.Lock()
+	s.lastAt = time.Now()
 	reason = strings.ToLower(reason)
 	switch {
 	case strings.Contains(reason, "interrupt"):
@@ -396,3 +430,15 @@ func formatCtxCell(tokens int) string {
 		return fmt.Sprintf("%d", tokens)
 	}
 }
+
+// barVerbose reports the BAR's verbosity under the lock. It is a method rather
+// than a field read because the render path asks for it on every frame, and a
+// racy read of a bool is still a race.
+func (s *sessionStatus) barVerbose() bool {
+	if s == nil {
+		return false
+	}
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.verbose
+}
@@ -0,0 +1,183 @@
+package cli
+
+// THE STATUS BAR, as a value.
+//
+// It used to be assembled: statusLine took a lock on a *sessionStatus,
+// formatted, shed tokens by rank and returned a string, all in one function
+// against the one session a process has. Multiplexing needs N of them — one per
+// pane — and a pane's bar must render without owning the session behind it.
+//
+// So the bar is now a VALUE and a PURE FUNCTION over it. Everything that reads
+// a clock, takes a lock or asks a daemon happens where the value is built;
+// render() does arithmetic on strings and nothing else, which is what lets it
+// be golden-tested at every width. See plans/status-bar-and-modes.md §1.
+
+import (
+	"strings"
+	"time"
+
+	"github.com/jack-work/figaro/internal/term"
+	"github.com/mattn/go-runewidth"
+)
+
+// statusView is everything the bar says.
+type statusView struct {
+	Drawer drawerID // what is open (drawerid.go); drawerNothing in the plain pager
+	State  turnStatus
+	Tick   uint64 // spinner frame, for the one state that animates
+	Aria   string
+	Mantra string
+	Ctx    string // already formatted: "9.8k/1.0m (1.0%)"
+	// Alert is the newest notification, projected into the bar. It is
+	// 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
+	// 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
+	Model   string // verbose only
+	Hints   string // verbose only: the keys this mode answers
+	Verbose bool
+}
+
+// lastAtFormat is a full datetime because the question it answers -- is this
+// conversation stale? -- outlives a single day, and a bare wall clock is
+// ambiguous on a pager left open across midnight.
+const lastAtFormat = "01/02/06 15:04:05"
+
+// render draws the bar: ONE row when both halves fit, THREE when they do not.
+//
+// Three, not two: the narrow form is left group, blank, right group, and the
+// blank is in the requirement. It is also the reason this returns rows rather
+// than a string — the caller reserves height from the same count, and a bar
+// that silently became taller than its reservation would eat a line of the
+// conversation.
+func (v statusView) render(w int) []string {
+	if w <= 0 {
+		return nil
+	}
+	left, right := v.groups()
+	l, r := joinFields(left), joinFields(right)
+
+	if r == "" {
+		return []string{clipToWidthEllipsis(l, w)}
+	}
+	if lw, rw := displayWidth(l), displayWidth(r); lw+rw+2 <= w {
+		gap := w - lw - rw
+		return []string{l + strings.Repeat(" ", gap) + r}
+	}
+	// THE MANTRA SHEDS FIRST, and only then does the bar grow a second row.
+	// Wrapping is cheaper than losing information, but a three-row bar on a
+	// wide-enough pane is worse than a bar without the mantra: the mantra is
+	// the one field whose absence costs nothing that is not recoverable by
+	// looking at the top of the screen.
+	if v.Mantra != "" {
+		trimmed := v
+		trimmed.Mantra = ""
+		if rows := trimmed.render(w); len(rows) == 1 {
+			return rows
+		}
+	}
+	return []string{
+		clipToWidthEllipsis(l, w),
+		"",
+		clipToWidthEllipsis(r, w),
+	}
+}
+
+// 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.
+	if v.Alert != "" {
+		left = append(left, term.NoticeInDim(v.Alert))
+	}
+	if tok := v.Drawer.token(v.Verbose); tok != "" {
+		left = append(left, tok)
+	}
+	if st := v.stateToken(); st != "" {
+		left = append(left, st)
+	}
+	if v.Aria != "" {
+		left = append(left, v.Aria)
+	}
+	if m := strings.Join(strings.Fields(v.Mantra), " "); m != "" {
+		left = append(left, truncRunes(m, 32))
+	}
+	if v.Verbose && v.Model != "" {
+		left = append(left, v.Model)
+	}
+	if v.Verbose && v.Hints != "" {
+		left = append(left, v.Hints)
+	}
+
+	if v.Ctx != "" {
+		right = append(right, v.Ctx)
+	}
+	if v.Verbose && !v.LastAt.IsZero() {
+		right = append(right, v.LastAt.Format(lastAtFormat))
+	}
+	return left, right
+}
+
+// stateToken is the state as the bar draws it: the glyph, plus its name under
+// verbose. Idle contributes nothing — it is the catch-all, and a row that is
+// always visible has nothing to say by saying "nothing is happening".
+func (v statusView) stateToken() string {
+	if v.State == turnStatusIdle {
+		return ""
+	}
+	sym := v.State.symbol(v.Tick)
+	if v.Verbose {
+		if name := v.State.name(); name != "" {
+			return v.State.paint(name + " " + sym)
+		}
+	}
+	return v.State.paint(sym)
+}
+
+// joinFields is the separator rule, and it is the reason wrapping is done by
+// GROUP rather than by column: `·` joins fields ON a row, so a group that
+// breaks across rows must not leave one dangling at the break.
+func joinFields(fields []string) string { return strings.Join(fields, " · ") }
+
+// ---------------------------------------------------------------------------
+// Building the value.
+// ---------------------------------------------------------------------------
+
+// viewOf snapshots a session into a statusView. This is where the lock is
+// taken and where the wall clock is read; render() does neither.
+func (s *sessionStatus) viewOf(drawer drawerID, verbose bool, now time.Time) statusView {
+	if s == nil {
+		return statusView{}
+	}
+	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,
+	}
+	if ctx := formatContextUsage(s.metrics.ContextTokens, s.metrics.ContextLimit, s.metrics.ContextExact); ctx != "-" {
+		v.Ctx = ctx
+	}
+	if verbose {
+		v.Model = s.model
+	}
+	return v
+}
+
+// barWidthOf reports how tall a bar of this view will be, so a caller that
+// reserves rows and a caller that draws them cannot disagree.
+func (v statusView) height(w int) int { return len(v.render(w)) }
+
+// truncRunes is shared with the old renderer.
+var _ = runewidth.StringWidth