jackherd 1.11.2 → 1.12.1

package/src/plans/layout.ts

@@ -30,11 +30,19 @@ import {
   type WatchHealth,
 } from '../watch/plan-badges'
 import type { UnplannedTask } from './active-tasks'
-import { type AppointmentBlock, appointmentItems, appointmentKeys } from './appointment-rows'
-import { deeper, type Frame, joinFrames, nest, prefixed, rowFrame, TREE, textFrame } from './frame'
+import { type AgentOf, clickHint } from './click-hint'
+import { type Frame, indented, joinFrames, narrower, rowFrame, spaced, textFrame, unpainted } from './frame'
 import { groomedText } from './groomed'
+import {
+  LANE_REASON,
+  type LaneReason,
+  laneReason,
+  lanesBalance,
+  type ReasonInput,
+  type UnblockingRow,
+} from './lane-reason'
 import { LANE_STANDING, type LaneStanding, laneStanding, waitingNote } from './lane-standing'
-import { type LaneSummary, laneSummary } from './lane-summary'
+import { type ActivePhase, type LaneSummary, laneSummary } from './lane-summary'
 import { type LaneTickets, withoutTicketKey } from './lane-tickets'
 import {
   COLUMN_SEPARATOR,
@@ -44,14 +52,18 @@ import {
   MIN_TITLE_WIDTH,
   nowLine,
   plain,
+  SHIMMERING_TASK,
+  STILL_TASK,
+  type TaskStyle,
 } from './layout-phase'
-import { foldedTaskLine, summaryChildren } from './layout-summary'
+import { foldedTaskLine, openLaneFrame } from './layout-summary'
+import { legendLines } from './legend'
 import { chipKey, type LinkChip, planUrlOf } from './link-chips'
-import { type NextBlock, nextItems, nextKeys } from './next-rows'
 import type { PhaseModel } from './phase-models'
 import { type PlannedPlan, plannedNextLabel } from './planned'
 import { CHECKS, type ChecksState, failedTestKey, type PullRequest, pullRequestKey } from './pull-requests'
 import {
+  blockRowByKey,
   boldBracketAt,
   buttonsAllBold,
   type FocusHit,
@@ -62,40 +74,39 @@ import {
   LINKS_KEY_PREFIX,
 } from './row-focus'
 import {
+  BACKLOG_KEY,
   type ClickTarget,
   isBlockFolded,
+  isBlockHeadKey,
   isLaneOpen,
+  isLanesOpen,
+  LANES_KEY,
   laneKey,
-  PLANNED_KEY,
   type Selection,
   selectedKey,
   TOP_BLOCK,
   type TopBlockId,
   targetKeys,
+  topBlockHeadKey,
+  WAITING_KEY,
 } from './selection'
 import type { SentChip } from './sent-files'
 import { shownWithMore } from './shown-with-more'
 import { askedCheckOf } from './source-asked'
-import { type SourceBlock, sourceItems, sourceKeys } from './source-rows'
-import { chevronOf, LESS_MARK, NO_AGENT_SYMBOL, statusSymbol, statusWord } from './symbols'
+import { type SourceBlock, type SourceSummary, sourceItems, sourceSummaries } from './source-rows'
+import { chevronOf, LESS_MARK, NO_AGENT_SYMBOL, statusSymbol, statusWord, TURN_MARK } from './symbols'
 import { BADGE_TEXTS, type BadgeTexts, checksText, laneMarkText, TEXTS } from './texts'
 import { paintOfRole, paintOfTone, toneOfRole } from './tones'
 import {
-  APPOINTMENT_MORE_KEY,
   allBlockRows,
   type BlockHit,
   type BlockRow,
-  blockRows,
   buttonsText,
-  moreKeyOf,
-  NEXT_MORE_KEY,
   SHOWN_BLOCK_ROWS,
   SOURCE_MORE_KEY,
-  WAITING_MARK,
-  WAITING_MORE_KEY,
-  waitingKeys,
-  waitingRows,
 } from './waiting-click'
+import { type TurnBalance, turnBalance, turnPage, type YourTurnBlock } from './your-turn'
+import { turnRows, YOUR_TURN_LATER_KEY, YOUR_TURN_MORE_KEY } from './your-turn-rows'
 
 /**
  * Where a lane stands outside its plan. `agent` is the terminal adapter's status, null when no agent is listed;
@@ -116,8 +127,6 @@ export type LaneView = {
   context?: ContextReading | null
   /** What the lane works on now, what comes next and after, and what is finished; derived from `progress` when absent. */
   summary?: LaneSummary
-  /** The title of the agent's session as the terminal shows it; absent when it has none. */
-  sessionTitle?: string
   /** A running lane the sprint table has no row for; drawn with the mark `no row in lanes`. */
   unlisted?: boolean
   /** Preview and feedback of the lane's pull requests from the running watcher's state; none without a watcher. */
@@ -135,38 +144,35 @@ export type LaneView = {
 /** `watch` is the health of the watcher the badges come from, absent when it was not read. */
 export type OverviewView = {
   title: string
-  time: string
   lanes: LaneView[]
   planned: PlannedPlan[]
   watch?: WatchHealth
   /** True when the config marks a ticket source, so a missing watcher is said without a pull request too. */
   watchesTickets?: boolean
-  /** The open items of the board's section of what waits on the user, shown under the title. */
+  /** The open items of the board's section of what waits on the user: which source entries "Your turn" holds. */
   awaiting?: WaitingItem[]
-  /** The board's next section, in a block of its own under the for-you block; absent for a herd without a board. */
-  next?: NextBlock
-  /** The open appointments of the board, in a block of their own under the next block. */
-  appointments?: AppointmentBlock
-  /** The sources the watcher runs that are not tickets, in a block of their own under the appointments. */
+  /** What is the user's turn, in a block under the title; absent for a herd without a board. */
+  yourTurn?: YourTurnBlock
+  /** The sources the watcher runs that are not tickets, in a block of their own under "Your turn". */
   sourceBlock?: SourceBlock
   /** Whole days since the board was groomed (`groomedDaysAgo`), beside the clock; null or absent when unknown. */
   groomedDays?: number | null
   /** What agents report doing that no lane takes, one `now:` line each under the title. */
   unplaced?: UnplannedTask[]
+  /** True when a folded lane's running task shimmers (`shimmerAt` draws it) instead of carrying its `●`. */
+  shimmer?: boolean
 }
 
 /**
  * The drawn screen: a fixed header and footer around a body that scrolls; body lines and targets count from the body's
- * top. `waitingBlock` and `appointmentBlock` are what a click on the for-you and the appointment block is matched
- * against, null while the block is not drawn.
+ * top. `yourTurnBlock` and `sourceBlock` are what a click on these blocks is matched against, null while the block is
+ * not drawn.
  */
 export type Screen = {
   header: string[]
   body: Frame
   footer: string[]
-  waitingBlock: BlockHit | null
-  nextBlock: BlockHit | null
-  appointmentBlock: BlockHit | null
+  yourTurnBlock: BlockHit | null
   sourceBlock: BlockHit | null
   /** Every clickable row by the screen line it starts on (header lines first, then the body unscrolled): what the mouse and the keys land on. */
   focusHits: FocusHit[]
@@ -189,30 +195,42 @@ type LaneColumns = { name: number; marks: number; right: number; phases: boolean
 type BlockLines = { open: boolean; lines: string[]; hit: Omit<BlockHit, 'firstLine'> }
 
 /**
- * What a block of the top of the herd is drawn from: its name, the bar of its lines, the paint of the mark that starts
- * a row, the key of its `+<n>` line, its points and their rows.
+ * What a block of the top of the herd is drawn from: its name, its count and balance in the head, the paint of the mark
+ * that starts a row, the key of its `+<n>` line and how many rows that line holds back, and its rows.
  */
 type TopBlock = {
   name: string
-  bar: () => string
+  /** The count after the name; null for a block whose head shows none (the sources). */
+  count: number | null
+  /** What the head says after the count, painted, open and folded alike; empty for nothing. */
+  balance: string
   markPaint: (text: string) => string
-  /** The paint of the buttons of a row: amber and bold in "Waiting for you", the normal foreground colour elsewhere. */
+  /** The paint of the buttons of a row: amber for "Your turn", the normal foreground colour elsewhere. */
   buttonPaint: (text: string) => string
-  /** Whether a row is the selected one or under the mouse: it gets the background, the mark, and bold buttons. */
+  /** Whether a row is the selected one or under the mouse: it gets the background, the mark, and its buttons. */
   focused: (key: string) => boolean
   /** Whether all buttons of a row are bold: the arrows selected it and the mouse is not on it (the mouse bolds one). */
   allBold: (key: string) => boolean
-  /** The paint of the count in the head while the block has points: amber for what waits on the user. */
+  /** The paint of the count in the head while it is more than 0: amber for what waits on the user. */
   countPaint: (text: string) => string
-  moreKey: string
+  moreKey: string | null
+  hidden: number
   expanded: boolean
-  keys: readonly string[]
   rows: BlockRow[]
 }
 
+/** What the head of a block says: its name, its count, its balance and the paint of the count. */
+type BlockHeadParts = Pick<TopBlock, 'name' | 'count' | 'balance' | 'countPaint'>
+
 /** The blocks on top of the herd one under the other: their lines below the title, and the hit of each drawn block. */
 type BlockStack = { lines: string[]; hits: (BlockHit | null)[] }
 
+/** What every lane of the lanes block is drawn with. */
+type LanesContext = { state: Selection; width: number; badgeTexts: BadgeTexts; taskStyle: TaskStyle }
+
+/** In front of every line of the lanes block under its head. */
+const LANE_INDENT = '  '
+
 const BRANCH_MARK = '⎇'
 const SENT_MARK = '📎'
 const SYMBOL_WIDTH = 2
@@ -230,11 +248,6 @@ const HEADER_MARK = '🐾'
 const COLUMN_RULE = '│'
 /** The number badge of a three-digit pull request (`↗ #` and the digits, a cell of padding either side); a longer one widens it. */
 const PULL_REQUEST_BADGE_WIDTH = 8
-/**
- * Under the lane line's status symbol: where the pull request row and its badge line start, and where the trunk
- * of an open lane hangs, not under the fold arrow.
- */
-const UNDER_STATUS = '  '
 const CHECKS_WIDTH = 10
 /** The most failed tests listed under a pull request; the rest is counted. */
 const SHOWN_FAILED_TESTS = 3
@@ -479,9 +492,24 @@ const STATUS_SEPARATOR = ' · '
 /** Between the checkbox count and the phase count of a lane. */
 const TALLY_SEPARATOR = ' · '
 
-/** `[✦ label]` linked to the chip's address, `private` faint inside it for a link its plan says is private. */
+/** How many cut chip labels the render keeps; a label is often a whole line of a plan, measured anew every frame otherwise. */
+const KEPT_LABELS = 2000
+
+const cutLabels = new Map<string, string>()
+
+/** The chip label cut to `CHIP_LABEL_WIDTH`, kept per label; the kept ones are dropped all at once when they are too many. */
+const cutLabel = (label: string): string => {
+  const kept = cutLabels.get(label)
+  if (kept !== undefined) return kept
+  if (cutLabels.size >= KEPT_LABELS) cutLabels.clear()
+  const cut = fit(plain(label), CHIP_LABEL_WIDTH)
+  cutLabels.set(label, cut)
+  return cut
+}
+
+/** `[🔗 label]` linked to the chip's address, `private` faint inside it for a link its plan says is private. */
 const chipCell = ({ url, icon, label, private: hidden }: LinkChip): string =>
-  bracket(url, `${icon} ${fit(plain(label), CHIP_LABEL_WIDTH)}`, hidden ? TEXTS.privateLink : '')
+  bracket(url, `${icon} ${cutLabel(label)}`, hidden ? TEXTS.privateLink : '')
 
 /** A badge and the key a click on it opens; null for a cell no click opens. */
 type BadgeCell = { cell: string; key: string | null }
@@ -640,35 +668,39 @@ const foldedPhaseLabel = (view: LaneView): string => {
   return `${nextPhaseLabel(view)}${more > 0 ? ` +${more}` : ''} · ${phase.done}/${phase.total}`
 }
 
-/** A lane whose agent rests (idle or done): the folded line says what it waits on instead of the phase and the bar. */
+/** A lane whose agent rests (idle or done): the folded line says what it waits on, and its phase without the bar. */
 const restsFolded = ({ status }: LaneView, open: boolean): boolean => !open && isRestingAgent(status.agent)
 
-/** The report's `waits on: <question>` split at its label, so the label can sit dim and the reason bright. */
-const noteParts = (note: string): { label: string; reason: string } => {
-  const split = note.indexOf(': ')
-  return split === -1 ? { label: '', reason: note } : { label: note.slice(0, split + 1), reason: note.slice(split + 2) }
+/**
+ * Why a resting lane rests, the label dim and the short text bright; a question to you has its label in the tone of
+ * what waits. Empty for a lane without a reason, which works.
+ */
+const reasonText = (reason: LaneReason | null): string => {
+  if (!reason) return ''
+  if (!reason.label) return reason.text
+  const label = reason.kind === LANE_REASON.you ? paintOfRole(TONE_ROLE.waiting)(reason.label) : paint.dim(reason.label)
+  return `${label} ${reason.text}`
+}
+
+/** `P4 12/18`: the phase a resting lane names and its ticked boxes, without the title the reason takes the room of. */
+const restingPhaseLabel = (view: LaneView): string => {
+  const phase = headPhase(view)
+  return phase ? paint.dim(`${phaseLabel(phase.id)} ${phase.done}/${phase.total}`) : ''
 }
 
 /**
- * Why a resting lane rests: the open question of its report (the watcher's `waits on:` line), else the starts-after
- * cell of the board (`after: …`), else the plain fact that nothing is known, which is meant to stand out.
+ * What follows the status on a lane line: the marker, the reason a resting lane rests, and, folded only, the phase it
+ * works on (a resting one by its label and count); the branch is on the session line. Wider than `room`, the reason
+ * is cut and the phase stays whole behind it.
  */
-const restDetail = (view: LaneView): string => {
-  const wait = waitingNote(view.progress.lane)
-  const { label, reason } = view.restNote
-    ? noteParts(view.restNote)
-    : wait !== null
-      ? { label: TEXTS.restAfter, reason: plain(wait) }
-      : { label: '', reason: TEXTS.restNoReason }
-  return label ? `${paint.dim(label)} ${reason}` : reason
-}
-
-/** What follows the status on a lane line: the marker and, folded only, the phase it works on; the branch is on the session line. */
-const laneDetail = (view: LaneView, open: boolean): string => {
+const laneDetail = (view: LaneView, open: boolean, reason: LaneReason | null, room: number): string => {
   const markText = laneMarkText(view)
   const marker = markText ? paint.yellow(markText) : ''
-  const phase = restsFolded(view, open) ? restDetail(view) : open ? '' : foldedPhaseLabel(view)
-  return [agentLabel(view.status.agent), marker, phase].filter(Boolean).join(' ')
+  const phase = restsFolded(view, open) ? restingPhaseLabel(view) : open ? '' : foldedPhaseLabel(view)
+  const lead = [agentLabel(view.status.agent), marker, reasonText(reason)].filter(Boolean).join(' ')
+  if (!reason || !phase) return [lead, phase].filter(Boolean).join(' ')
+  const leadRoom = Math.max(room - COLUMN_SEPARATOR.length - visibleLength(phase), 1)
+  return `${visibleLength(lead) > leadRoom ? fit(lead, leadRoom) : lead}${COLUMN_SEPARATOR}${phase}`
 }
 
 /**
@@ -684,11 +716,26 @@ export const withDetail = (
   indent = CONTENT_INDENT,
 ): string[] => {
   if (!detail) return [spread(head, right, width)]
-  const room = width - visibleLength(head) - COLUMN_SEPARATOR.length - visibleLength(right) - 1
-  if (room >= MIN_BESIDE_WIDTH) return [spread(`${head}${COLUMN_SEPARATOR}${detail}`, right, width)]
+  if (detailPlacement(head, right, width, indent).beside)
+    return [spread(`${head}${COLUMN_SEPARATOR}${detail}`, right, width)]
   return [spread(head, right, width), fit(`${indent}${detail}`, width)]
 }
 
+/**
+ * Where `withDetail` puts a detail and how many cells it has there: beside `head` and `right` while at least
+ * `MIN_BESIDE_WIDTH` are left on that line, else on a line of its own behind `indent`.
+ */
+const detailPlacement = (
+  head: string,
+  right: string,
+  width: number,
+  indent: string,
+): { beside: boolean; room: number } => {
+  const besideRoom = width - visibleLength(head) - COLUMN_SEPARATOR.length - visibleLength(right) - 1
+  const beside = besideRoom >= MIN_BESIDE_WIDTH
+  return { beside, room: beside ? besideRoom : width - visibleLength(indent) }
+}
+
 /** The summary the snapshot read for the lane, or the one its own steps give. */
 const summaryOf = (view: LaneView): LaneSummary =>
   view.summary ?? laneSummary({ progress: view.progress, phases: {}, activity: {} }, 0)
@@ -699,10 +746,14 @@ const laneProgressColumn = (view: LaneView, tallyWidth: number): string => {
   return tally.total > 0 ? progressColumn(tally, tallyWidth) : ''
 }
 
-/** Context and bar at the right edge of a folded lane line, as wide as the lane has them. */
+/** The context value alone, from `warn` on, for a lane line that draws no bar after it; empty below or without a reading. */
+const loneContextValue = (context: ContextReading | null | undefined): string =>
+  context && context.level !== CONTEXT_LEVEL.ok ? contextValue(context) : ''
+
+/** Context and bar at the right edge of a folded lane line, as wide as the lane has them; no rule without a bar. */
 const laneRight = (view: LaneView, tallyWidth: number): string => {
   const counts = restsFolded(view, false) ? '' : laneProgressColumn(view, tallyWidth)
-  return counts ? `${contextCell(view.context)}${counts}` : contextCell(view.context).trimEnd()
+  return counts ? `${contextCell(view.context)}${counts}` : loneContextValue(view.context)
 }
 
 /** The cells of the phase count column, 0 when the pane leaves it out. */
@@ -718,99 +769,88 @@ const markedRight = (view: LaneView, columns: LaneColumns): string => {
   return `${padVisible(marks, columns.marks)}${COLUMN_SEPARATOR}${pad}${right}`
 }
 
-/**
- * Before a lane's detail on a line of its own: blanks up to the column of the lane's name, so a folded lane's title
- * starts where its name does, as the branches of an open lane do; an open lane keeps its trunk in front.
- */
-const detailIndent = (open: boolean, nameColumn: number): string => {
-  if (!open) return ' '.repeat(nameColumn)
-  const trunk = `${UNDER_STATUS}${TREE.pipe}`
-  return `${paint.dim(trunk)}${' '.repeat(Math.max(nameColumn - visibleLength(trunk), 0))}`
-}
-
-/** The task row below a folded lane's phase row, under the lane's name; none while the phase has no task on it. */
-const foldedTaskRow = (view: LaneView, indent: string, width: number): string[] => {
+/** The task row below a folded lane's phase row, under the lane's name; none while the lane reports no task. */
+const foldedTaskRow = (view: LaneView, indent: string, width: number, style: TaskStyle): string[] => {
   const phase = headPhase(view)
-  const { active: running, subagentTasks } = summaryOf(view)
-  const active = running.find((each) => each.phase.id === phase?.id)
-  const line = active && foldedTaskLine(active, subagentTasks, TEXTS.herd, indent, width)
+  const summary = summaryOf(view)
+  const active = summary.active.find((each) => each.phase.id === phase?.id)
+  const line = foldedTaskLine(active, summary, TEXTS.herd, { indent, width, style })
   return line ? [line] : []
 }
 
-const laneLines = (view: LaneView, open: boolean, width: number, columns: LaneColumns): string[] => {
+/**
+ * The lines of a lane's own row: chevron, status symbol, name, detail and right column; a detail on a line of its own,
+ * and a folded lane's task row, start in the column of the name, as the children of an open lane do.
+ */
+const laneLines = (
+  view: LaneView,
+  open: boolean,
+  { width, taskStyle }: Pick<LanesContext, 'width' | 'taskStyle'>,
+  columns: LaneColumns,
+  reason: LaneReason | null,
+): string[] => {
   const { progress, status } = view
   const nameStyle = restsFolded(view, open) ? paint.dim : paint.bold
   const cells = padVisible(nameStyle(fit(progress.lane.name, columns.name)), columns.name)
   const head = `${paint.dim(chevronOf(open))} ${symbolCell(status.agent)} ${cells}`
   const right = open ? laneProgressColumn(view, tallyWidthOf(columns)) : markedRight(view, columns)
-  const nameColumn = visibleLength(head) - visibleLength(cells)
-  const lines = withDetail(head, laneDetail(view, open), right, width, detailIndent(open, nameColumn))
-  return open ? lines : [...lines, ...foldedTaskRow(view, ' '.repeat(nameColumn), width)]
+  const nameIndent = ' '.repeat(visibleLength(head) - visibleLength(cells))
+  const { room } = detailPlacement(head, right, width, nameIndent)
+  const lines = withDetail(head, laneDetail(view, open, reason, room), right, width, nameIndent)
+  return open ? lines : [...lines, ...foldedTaskRow(view, nameIndent, width, taskStyle)]
 }
 
-/** The parts of a session line: the session's title (the branch without one) at the left, the branch and the context value. */
-const sessionParts = (view: LaneView): { left: string; git: string; branch: string; context: string } => {
-  const git = gitLabel(view.status)
-  const branch = branchLabel(view.status)
-  return { left: view.sessionTitle ? plain(view.sessionTitle) : git, git, branch, context: contextValue(view.context) }
+/** The running phase the lane line names, with its step and age; undefined while it names none or that one does not run. */
+const headActive = (view: LaneView): ActivePhase | undefined => {
+  const phase = headPhase(view)
+  return phase ? summaryOf(view).active.find((active) => active.phase.id === phase.id) : undefined
 }
 
 /**
- * The session branch of an open lane: the session's title at the left; the branch at the end of the line, before the
- * context at the right. The title keeps its room: the branch gives way when both do not fit, and only then is the
- * title cut. Without a title the branch stands at the left.
+ * `Opus`: the model cell of the board row the lane works on, the row of its running phase, else of its current one;
+ * empty when that cell is. Not the model a subagent ran on, which may differ from the lane's own session.
  */
-const sessionLine = (view: LaneView, width: number): string => {
-  const { left, git, branch, context } = sessionParts(view)
-  if (!view.sessionTitle) return spread(fit(git, Math.max(width - CONTEXT_CELL_WIDTH, 1)), context, width)
-  const room = width - (context ? CONTEXT_CELL_WIDTH : 0)
-  const fitting = [git, branch].find(
-    (label) => visibleLength(left) + COLUMN_SEPARATOR.length + visibleLength(label) <= room,
-  )
-  const right = [fitting ?? '', context].filter(Boolean).join(COLUMN_SEPARATOR)
-  return spread(fit(left, Math.max(room, 1)), right, width)
+const modelLabel = (view: LaneView): string => {
+  const { lane, current } = view.progress
+  const stepIndex = headActive(view)?.stepIndex ?? current?.stepIndex
+  return stepIndex === undefined ? '' : plain(lane.steps[stepIndex]?.model ?? '').trim()
+}
+
+/** `idle 4 h`: how long a resting lane's phase has not moved; empty while the lane works or the herd saw no move. */
+const idleLabel = (view: LaneView): string => {
+  const minutes = isRestingAgent(view.status.agent) ? headActive(view)?.minutesAgo : null
+  return minutes === null || minutes === undefined ? '' : TEXTS.idleFor(minutes)
 }
 
 /**
- * The session line with the lane's one link chip on it, so the lane needs no row of chips: title, chip, branch and
- * context. When the line is short the ahead and dirty counts of the branch go first, then the title is cut with `…`;
- * without a title the branch stands at the left and the chip at the right. Null when even the cut title would be
- * narrower than `MIN_TITLE_WIDTH`, and the chip keeps its row of chips.
+ * The session line of an open lane: `⎇ branch ↑2 ±1 · Sonnet · idle 4 h`, the branch with its counts, the model and the
+ * rest dim, cut before the context value at the right.
  */
-const sessionWithChip = (view: LaneView, chip: BadgeCell, width: number): Frame | null => {
-  const { left, git, branch, context } = sessionParts(view)
-  const tails = view.sessionTitle
-    ? [
-        [chip.cell, git, context],
-        [chip.cell, branch, context],
-      ]
-    : [[chip.cell, context]]
-  const candidates = tails.map((tail) => tail.filter(Boolean).join(COLUMN_SEPARATOR))
-  const roomFor = (candidate: string) => width - COLUMN_SEPARATOR.length - visibleLength(candidate)
-  const narrowest = candidates[candidates.length - 1] ?? ''
-  const cuts = Boolean(view.sessionTitle) && roomFor(narrowest) >= MIN_TITLE_WIDTH
-  const right = candidates.find((candidate) => visibleLength(left) <= roomFor(candidate)) ?? (cuts ? narrowest : null)
-  if (right === null) return null
-  const from = width - visibleLength(right)
-  const targets = chip.key === null ? [] : [{ line: 0, from, to: from + visibleLength(chip.cell), key: chip.key }]
-  return { lines: [spread(left, right, width)], cursorLine: -1, targets }
-}
-
-/** Session and link chips of an open lane: a lone chip on the session line when it fits there, else a row of chips. */
-const sessionAndChips = (
-  view: LaneView,
-  tickets: LaneTickets | null,
-  width: number,
-): { session: Frame; chips: Frame } => {
-  const cells = chipCells(laneChips(view), tickets, view.sentFiles)
-  const [lone] = cells
-  const inline = cells.length === 1 && lone ? sessionWithChip(view, lone, width) : null
-  if (inline) return { session: inline, chips: textFrame([]) }
-  return { session: textFrame([sessionLine(view, width)]), chips: packedFrame(cells, '', width) }
+const sessionLine = (view: LaneView, width: number): string => {
+  const words = [modelLabel(view), idleLabel(view)].filter(Boolean).map((word) => paint.dim(word))
+  const left = [gitLabel(view.status), ...words].join(paint.dim(PLACE_SEPARATOR))
+  const context = contextValue(view.context)
+  return spread(fit(left, Math.max(width - (context ? CONTEXT_CELL_WIDTH : 0), 1)), context, width)
 }
 
-const underStatus = (frame: Frame): Frame =>
-  prefixed(frame, { first: UNDER_STATUS, rest: UNDER_STATUS, style: (text) => text })
+/** How many of `cells` fit on one line of `width` cells with the `+<n>` for the rest; at least one, which is then cut. */
+const fittingChips = (cells: BadgeCell[], width: number): number => {
+  const fits = (count: number) => {
+    const rest = cells.length - count
+    return packedWidth(cells.slice(0, count)) + (rest > 0 ? CHIP_GAP.length + `+${rest}`.length : 0) <= width
+  }
+  return Array.from({ length: cells.length }, (_, index) => cells.length - index).find(fits) ?? 1
+}
+
+/** The link chips of an open lane on one line, `+<n>` dim for the ones past the pane's edge; each chip a click target over its columns. */
+const chipLine = (cells: BadgeCell[], width: number): Frame => {
+  if (cells.length === 0) return textFrame([])
+  const count = fittingChips(cells, width)
+  const shown = cells.slice(0, count)
+  const rest = cells.length - count
+  const line = `${shown.map(({ cell }) => cell).join(CHIP_GAP)}${rest > 0 ? `${CHIP_GAP}${paint.dim(`+${rest}`)}` : ''}`
+  return { lines: [fit(line, width)], cursorLine: -1, targets: cellTargets(shown, 0, 0, width) }
+}
 
 /** The chips of the plans the lane's steps name, in the order of its steps. */
 const laneChips = ({ progress, chips }: LaneView): LinkChip[] =>
@@ -826,13 +866,15 @@ const pullRequestsFrame = (view: LaneView, context: LaneContext): Frame => {
   )
 }
 
-/** The lane line is a row of its own; an open lane continues with its pull requests and plans. */
+/**
+ * The lane line is a row of its own; an open lane continues after a blank line with its session, links, pull requests
+ * and phases (`openLaneFrame`), indented to the column of the lane's name.
+ */
 const laneBlock = (
   view: LaneView,
-  state: Selection,
-  width: number,
+  { state, width, badgeTexts, taskStyle }: LanesContext,
   columns: LaneColumns,
-  badgeTexts: BadgeTexts,
+  reason: LaneReason | null,
 ): Frame => {
   const context: LaneContext = {
     progress: view.progress,
@@ -843,20 +885,20 @@ const laneBlock = (
     badgeTexts,
     tickets: view.tickets ?? null,
     models: view.models ?? {},
+    taskStyle,
   }
   const open = isLaneOpen(state, view.progress.lane.name, view.status.agent)
-  const row = rowFrame(laneKey(view.progress.lane.name), laneLines(view, open, width, columns), [], context)
+  const lines = laneLines(view, open, { width, taskStyle }, columns, reason)
+  const row = rowFrame(laneKey(view.progress.lane.name), lines, [], context)
   if (!open) return row
-  const inner = deeper({ ...context, width: Math.max(width - UNDER_STATUS.length, 1) })
-  const head = { ...sessionAndChips(view, inner.tickets, inner.width), pullRequests: pullRequestsFrame(view, inner) }
-  const [session, ...sections] = summaryChildren(inner, summaryOf(view), head)
-  const alone = sections.every((section) => section.lines.length === 0)
-  const sessionLead = alone ? { first: TREE.last, rest: TREE.gap } : { first: TREE.branch, rest: TREE.pipe }
-  return joinFrames([
-    row,
-    underStatus(prefixed(session, { ...sessionLead, style: paint.dim })),
-    underStatus(nest(sections)),
-  ])
+  const inner = narrower(context, LANE_HEAD_CELLS)
+  const head = {
+    session: textFrame([sessionLine(view, inner.width)]),
+    chips: chipLine(chipCells(laneChips(view), inner.tickets, view.sentFiles), inner.width),
+    pullRequests: pullRequestsFrame(view, inner),
+  }
+  const children = openLaneFrame(inner, summaryOf(view), head)
+  return joinFrames([row, textFrame(['']), indented(children, ' '.repeat(LANE_HEAD_CELLS))])
 }
 
 const laneTally = ({ progress }: Pick<LaneView, 'progress'>): string =>
@@ -868,16 +910,49 @@ const parkedItem = (view: Pick<LaneView, 'progress'>): string => {
   return label.replaceAll(' ', NON_BREAKING_SPACE)
 }
 
-/** `  name 2/5  after P1 gemergt`: one dimmed row per lane that waits, its wait cut at the pane's edge. */
-const waitingBlock = (lanes: LaneView[], width: number): string[] => {
-  if (lanes.length === 0) return []
-  const head = paint.dim(`${NO_AGENT_SYMBOL} ${TEXTS.waiting(lanes.length)}`)
-  const rows = lanes.map((lane) => {
-    const note = waitingNote(lane.progress.lane)
-    const item = laneTally(lane)
-    return paint.dim(fit(note === null ? `  ${item}` : `  ${item}  ${TEXTS.startsAfter(plain(note))}`, width))
-  })
-  return [head, ...rows]
+/**
+ * A block of the body: its head a row under `key` (`▸ <name> · <n>  <balance>` folded, the rule after it open), and
+ * the lines of `content` under it while open.
+ */
+const bodyBlock = (
+  key: string,
+  head: BlockHeadParts,
+  open: boolean,
+  content: () => Frame,
+  { state, width }: { state: Selection; width: number },
+): Frame =>
+  joinFrames([rowFrame(key, [blockHead(head, open, width)], [], { state, width }), ...(open ? [content()] : [])])
+
+/** The names of the lanes, dim and joined, the ones past the pane's edge left out. */
+const laneNames = (lanes: readonly LaneView[], width: number): string =>
+  paint.dim(
+    visibleStart(
+      lanes.map(({ progress }) => progress.lane.name),
+      ', ',
+      width,
+    ),
+  )
+
+/**
+ * The lanes that wait for their start, folded until the user opens them (`▸ Waiting · 2  name, other`); open,
+ * `  name 2/5  after P1 gemergt` per lane, dimmed and cut at the pane's edge.
+ */
+const waitingFrame = (lanes: LaneView[], state: Selection, width: number): Frame => {
+  const rows = () =>
+    textFrame(
+      lanes.map((lane) => {
+        const note = waitingNote(lane.progress.lane)
+        const item = laneTally(lane)
+        return paint.dim(fit(note === null ? `  ${item}` : `  ${item}  ${TEXTS.startsAfter(plain(note))}`, width))
+      }),
+    )
+  const head = {
+    name: TEXTS.waitingHeading,
+    count: lanes.length,
+    balance: laneNames(lanes, width),
+    countPaint: unpainted,
+  }
+  return bodyBlock(WAITING_KEY, head, state.expanded.has(WAITING_KEY), rows, { state, width })
 }
 
 /** `· no agent (6)  name 3/9 · other 1/4`: one wrapping block for every parked lane, each with its progress. */
@@ -891,16 +966,36 @@ const parkedBlock = (lanes: LaneView[], width: number): string[] => {
   return besideHead(head, items.join(' '), width, (line) => paint.dim(line.replaceAll(NON_BREAKING_SPACE, ' ')))
 }
 
+/** The texts joined by `separator`, the ones that start past `width` cells left out: what follows is cut anyway. */
+const visibleStart = (texts: readonly string[], separator: string, width: number): string => {
+  const shown: string[] = []
+  let used = 0
+  for (const text of texts) {
+    if (used > width) break
+    shown.push(text)
+    used += visibleLength(text) + separator.length
+  }
+  return shown.join(separator)
+}
+
 /**
- * The closing row for the phases no lane works on, dimmed and closed unless its key is expanded. Opened, it
- * lists each plan with its open phases and their checkboxes, and no checkbox itself.
+ * The backlog, the phases no lane works on, folded until the user opens it: `▸ Backlog · <plans>  next: Plan P3, …`.
+ * Opened, it lists each plan with its next phase and its checkboxes, and no checkbox itself.
  */
-const plannedFrame = (planned: PlannedPlan[], state: Selection, width: number): Frame => {
-  if (planned.length === 0) return textFrame([])
-  const open = state.expanded.has(PLANNED_KEY)
-  const next = planned.map((plan) => `${plain(plan.title)} ${plannedNextLabel(plan)}`).join(', ')
-  const head = [paint.dim(fit(`${chevronOf(open)} ${TEXTS.plannedHead(planned.length)} ${next}`, width))]
-  return rowFrame(PLANNED_KEY, head, open ? plannedRows(planned, width, CONTENT_INDENT).flat() : [], { state, width })
+const backlogFrame = (planned: PlannedPlan[], state: Selection, width: number): Frame => {
+  const next = visibleStart(
+    planned.map((plan) => `${plain(plan.title)} ${plannedNextLabel(plan)}`),
+    ', ',
+    width,
+  )
+  const head = {
+    name: TEXTS.backlogHeading,
+    count: planned.length,
+    balance: paint.dim(`${TEXTS.backlogNext} ${next}`),
+    countPaint: unpainted,
+  }
+  const rows = () => textFrame(plannedRows(planned, width, CONTENT_INDENT).flat())
+  return bodyBlock(BACKLOG_KEY, head, state.expanded.has(BACKLOG_KEY), rows, { state, width })
 }
 
 /** A dimmed row per plan, one list of lines each: its title and open phases at the left, its open checkbox count at the right. */
@@ -917,20 +1012,20 @@ const plannedRows = (planned: PlannedPlan[], width: number, indent: string): str
 
 const rule = (width: number): string => paint.dim(RULE.repeat(width))
 
-/** The amber bar that starts every line of the for-you block: the one signal that this waits on the user. */
-const waitingBar = (): string => statusPaint(AGENT_STATUS.blocked)(WAITING_MARK)
-
-/** The grey bar of the appointment block: it waits on nobody's answer. */
-const appointmentBar = (): string => paint.dim(WAITING_MARK)
+/** The blank that starts every line of a block on top: no bar, the mark of a row says what it is. */
+const blockBar = (): string => ' '
 
 /**
- * The head of an open block, `▾ <name> · <n> ──`, filled with the rule to the width, so it is the rule above the block.
- * The label and the count wear the normal colour (the count in `countPaint`), only the rule is dim.
+ * The head of a block, `▾ <name> · <n>  <balance> ──` while open, filled with the rule to the width, so it is the rule
+ * above the block; `▸ <name> · <n>  <balance>` while folded. The count (in `countPaint` while it is more than 0) is
+ * left out for a block without one; the balance comes painted.
  */
-const blockHead = (name: string, count: number, width: number, countPaint: (text: string) => string): string => {
-  const lead = `${chevronOf(true)} ${name} ${ITEM_SEPARATOR} `
-  const used = textWidth(`${lead}${count} `)
-  return `${lead}${countPaint(String(count))} ${paint.dim(RULE.repeat(Math.max(width - used, 0)))}`
+const blockHead = ({ name, count, balance, countPaint }: BlockHeadParts, open: boolean, width: number): string => {
+  const counted = count === null ? '' : ` ${ITEM_SEPARATOR} ${count > 0 ? countPaint(String(count)) : count}`
+  const lead = `${paint.dim(chevronOf(open))} ${name}${counted}${balance ? `  ${balance}` : ''}`
+  if (!open) return fit(lead, width)
+  const cut = fit(lead, Math.max(width - 2, 1))
+  return `${cut} ${paint.dim(RULE.repeat(Math.max(width - visibleLength(cut) - 1, 0)))}`
 }
 
 const markedLine = (line: string, row: BlockRow, markPaint: (text: string) => string): string => {
@@ -946,133 +1041,120 @@ const dimmedRest = (text: string, from: number): string => {
 
 /**
  * One row as lines: the bar on each, the mark painted on the first line only, the short title in the normal colour
- * and the rest of an expanded row dim, linked when the row has an address; the `[ask]` button at the end of a
- * question's first line wears the mark's paint.
+ * and the rest of an expanded row dim, linked when the row has an address. The buttons at the end of the first line
+ * are drawn only on the focused row, in the block's button paint; they keep their columns on every row.
  */
 const blockRowLines = (
-  { bar, markPaint, buttonPaint, focused, allBold }: TopBlock,
+  { markPaint, buttonPaint, focused, allBold }: TopBlock,
   row: BlockRow,
   width: number,
 ): string[] => {
   const hot = focused(row.key)
   const paintButton = (text: string) => (allBold(row.key) ? paint.bold(buttonPaint(text)) : buttonPaint(text))
   return row.lines.map((line, index) => {
-    const withButton = index === 0 && row.buttons.length > 0
+    const withButton = hot && index === 0 && row.buttons.length > 0
     const styled = dimmedRest(line, row.dimFrom[index] ?? line.length)
     const marked = index === 0 ? markedLine(styled, row, markPaint) : styled
     const shown = row.url ? link(row.url, marked) : marked
     const buttons = withButton ? buttonsText(row.buttons, row.dim ? paint.dim : paintButton) : ''
-    const drawn = `${bar()} ${shown}${buttons}`
+    const drawn = `${blockBar()} ${shown}${buttons}`
     return hot ? focusLine(drawn, width, index === 0) : drawn
   })
 }
 
-/** A folded block: the one line `▸ <name> · <n>` and the first title as a preview; a click matches no row and no `+<n>` line. */
-const foldedBlockLines = ({ name, keys, rows }: TopBlock, width: number): BlockLines => {
-  const preview = rows[0]?.preview
-  const head = `${chevronOf(false)} ${name} ${ITEM_SEPARATOR} ${keys.length}`
-  return {
-    open: false,
-    lines: [paint.dim(fit(preview === undefined ? head : `${head}  ${preview}`, width))],
-    hit: { rows: [], moreKey: null, keys },
-  }
+/** A folded block: its head alone, which keeps the count and the balance; a click matches no row and no `+<n>` line. */
+const foldedBlockLines = (block: TopBlock, headKey: string, width: number): BlockLines => ({
+  open: false,
+  lines: [focusedHead(block, headKey, false, width)],
+  hit: { rows: [], moreKey: null, headKey },
+})
+
+/** The head of a block on top, drawn like a focused row while the arrows or the mouse are on it. */
+const focusedHead = (block: TopBlock, headKey: string, open: boolean, width: number): string => {
+  const head = blockHead(block, open, width)
+  return block.focused(headKey) ? focusLine(head, width, true) : head
 }
 
 /**
- * An open block on top of the herd: the head `▾ <name> · <n> ──`, one barred line per row (the first five, all while the
- * block is expanded) and `▌ +<n>` for the rest, which turns into `▌ ▴ <n>` once all show and folds them again. A row wider than the pane is cut to
- * one line; once expanded it wraps over several. The rule below is the stack's, not the block's.
+ * An open block on top of the herd: the head, one line per row and `+<n>` for the rows `hidden` holds back, which turns
+ * into `▴ <n>` once all show and folds them again. A row wider than the pane is cut to one line; once expanded it
+ * wraps over several. The rule below is the stack's, not the block's.
  */
-const openBlockLines = (block: TopBlock, width: number): BlockLines => {
-  const count = block.keys.length
-  const more = Math.max(count - SHOWN_BLOCK_ROWS, 0)
-  const moreLine = block.expanded ? `${LESS_MARK} ${more}` : `+${more}`
+const openBlockLines = (block: TopBlock, headKey: string, width: number): BlockLines => {
+  const moreLine = block.expanded ? `${LESS_MARK} ${block.hidden}` : `+${block.hidden}`
+  const withMore = block.moreKey !== null && block.hidden > 0
   return {
     open: true,
     lines: [
-      blockHead(block.name, count, width, count > 0 ? block.countPaint : (text) => text),
+      focusedHead(block, headKey, true, width),
       ...block.rows.flatMap((row) => blockRowLines(block, row, width)),
-      ...(more > 0 ? [`${block.bar()} ${moreLine}`] : []),
+      ...(withMore ? [`${blockBar()} ${moreLine}`] : []),
     ],
-    hit: { rows: block.rows, moreKey: moreKeyOf(count, block.moreKey), keys: block.keys },
+    hit: { rows: block.rows, moreKey: withMore ? block.moreKey : null, headKey },
   }
 }
 
-const blockLinesOf = (block: TopBlock, state: Selection, id: TopBlockId, width: number): BlockLines =>
-  isBlockFolded(state, id, block.keys) ? foldedBlockLines(block, width) : openBlockLines(block, width)
-
-/**
- * What waits on the user's answer, on top of the herd until it is closed: `▌ 📎 name` for a sent file or an
- * Artifact, `▌ ? question` for a question of the board or of a session's dialog, in the amber of a lane that waits.
- * One line while the user folded it.
- */
-const waitingLines = (waiting: readonly WaitingItem[], state: Selection, width: number): BlockLines => {
-  const keys = waitingKeys(waiting)
-  const block: TopBlock = {
-    name: TEXTS.waitingHeading,
-    bar: waitingBar,
-    markPaint: statusPaint(AGENT_STATUS.blocked),
-    buttonPaint: statusPaint(AGENT_STATUS.blocked),
-    focused: (key) => isFocused(state, key),
-    allBold: (key) => buttonsAllBold(state, key),
-    countPaint: statusPaint(AGENT_STATUS.blocked),
-    moreKey: WAITING_MORE_KEY,
-    expanded: state.expanded.has(WAITING_MORE_KEY),
-    keys,
-    rows: waitingRows(waiting, state.expanded, width),
-  }
-  return blockLinesOf(block, state, TOP_BLOCK.waiting, width)
+const blockLinesOf = (block: TopBlock, state: Selection, id: TopBlockId, width: number): BlockLines => {
+  const headKey = topBlockHeadKey(id)
+  return isBlockFolded(state, id) ? foldedBlockLines(block, headKey, width) : openBlockLines(block, headKey, width)
 }
 
-/** The open appointments of the board under the for-you block: `▌ ◷ Mo 09:03 Release 2.0 rollout`, in a grey bar and with a grey mark. */
-const appointmentLines = ({ rows }: AppointmentBlock, state: Selection, width: number): BlockLines => {
-  const keys = appointmentKeys(rows)
-  const block: TopBlock = {
-    name: TEXTS.appointmentHeading,
-    bar: appointmentBar,
-    markPaint: paint.dim,
-    buttonPaint: (text) => text,
-    focused: (key) => isFocused(state, key),
-    allBold: (key) => buttonsAllBold(state, key),
-    countPaint: (text) => text,
-    moreKey: APPOINTMENT_MORE_KEY,
-    expanded: state.expanded.has(APPOINTMENT_MORE_KEY),
-    keys,
-    rows: blockRows(appointmentItems(rows), state.expanded, width, APPOINTMENT_MORE_KEY),
-  }
-  return blockLinesOf(block, state, TOP_BLOCK.appointments, width)
-}
+/** `4 block lanes · oldest 12 d`: what blocks a lane in the tone of what waits, the age dim. */
+const balanceText = ({ blocking, oldest }: TurnBalance): string =>
+  [blocking === null ? '' : paintOfRole(TONE_ROLE.waiting)(blocking), oldest === null ? '' : paint.dim(oldest)]
+    .filter(Boolean)
+    .join(paint.dim(` ${ITEM_SEPARATOR} `))
 
-/** The bar of the next block: a blank, since it asks nothing of the user and only its numbers lead the rows. */
-const nextBar = (): string => ' '
+/** The mark of a row of "Your turn": `?` and `📎` in the tone of what waits, `◷` in the tone of what is planned, chevrons dim. */
+const turnMarkPaint = (mark: string): string => {
+  if (mark === TURN_MARK.planned) return paintOfRole(TONE_ROLE.planned)(mark)
+  return mark === chevronOf(true) || mark === chevronOf(false) ? paint.dim(mark) : paintOfRole(TONE_ROLE.waiting)(mark)
+}
 
-/** The next block names nothing queued in one dim line, which has no rows to click. */
-const emptyNextLines = (): BlockLines => ({
+/** "Your turn" without a point: one line that cannot be opened, its name in the column of the other block names. */
+const emptyTurnLines = (): BlockLines => ({
   open: false,
-  lines: [paint.dim(`${TEXTS.nextHeading} ${ITEM_SEPARATOR} ${TEXTS.nextEmpty}`)],
-  hit: { rows: [], moreKey: null, keys: [] },
+  lines: [`${blockBar()} ${TEXTS.yourTurnHeading} ${paint.dim(`${ITEM_SEPARATOR} ${TEXTS.yourTurnEmpty}`)}`],
+  hit: { rows: [], moreKey: null },
 })
 
-/** The board's next section under the for-you block: `  1 Answer the phone tests`, numbered, without the amber bar. */
-const nextLines = ({ rows }: NextBlock, state: Selection, width: number): BlockLines => {
-  if (rows.length === 0) return emptyNextLines()
+/**
+ * What is the user's turn, on top of the herd: the head `Your turn · <n>` with its balance, folded until the user opens
+ * it; open, the now rows and the planned rows (`turnRows`), told apart by their mark alone.
+ */
+const yourTurnLines = ({ turn, now }: YourTurnBlock, state: Selection, width: number): BlockLines => {
+  const count = turn.now.length + turn.planned.length
+  if (count === 0) return emptyTurnLines()
+  const opened = { allNow: state.expanded.has(YOUR_TURN_MORE_KEY), allPlanned: state.expanded.has(YOUR_TURN_LATER_KEY) }
+  const clock = new Date(now)
   const block: TopBlock = {
-    name: TEXTS.nextHeading,
-    bar: nextBar,
-    markPaint: paint.dim,
-    buttonPaint: (text) => text,
+    name: TEXTS.yourTurnHeading,
+    count,
+    balance: balanceText(turnBalance(turn, clock)),
+    markPaint: turnMarkPaint,
+    buttonPaint: paintOfRole(TONE_ROLE.waiting),
     focused: (key) => isFocused(state, key),
     allBold: (key) => buttonsAllBold(state, key),
-    countPaint: (text) => text,
-    moreKey: NEXT_MORE_KEY,
-    expanded: state.expanded.has(NEXT_MORE_KEY),
-    keys: nextKeys(rows),
-    rows: blockRows(nextItems(rows), state.expanded, width, NEXT_MORE_KEY),
+    countPaint: turn.now.length > 0 ? paintOfRole(TONE_ROLE.waiting) : (text) => text,
+    moreKey: null,
+    hidden: 0,
+    expanded: false,
+    rows: turnRows(turnPage(turn, opened, clock), width),
   }
-  return blockLinesOf(block, state, TOP_BLOCK.next, width)
+  return blockLinesOf(block, state, TOP_BLOCK.yourTurn, width)
 }
 
-/** The sources the watcher runs: `  ● errors ran 12 min ago · <newest report>`, the mark amber while the report is new, red while the source fails. */
+/** `grafana 5 entries, 1 new · seobility 7 h ago`, each source in its tone, dim without one. */
+const sourceSummaryText = (summaries: readonly SourceSummary[]): string =>
+  summaries
+    .map(({ text, tone }) => (tone ? paintOfTone(tone)(text) : paint.dim(text)))
+    .join(paint.dim(` ${ITEM_SEPARATOR} `))
+
+/**
+ * The sources the watcher runs, as one line until the user opens it (`▸ Sources  grafana 5 entries, 1 new`); open,
+ * `● errors ran 12 min ago · <newest report>` per source, the mark amber while the report is new, red while the source
+ * fails, and a source's entries under it once opened.
+ */
 const sourceLines = (
   { sources, now }: SourceBlock,
   awaiting: readonly WaitingItem[],
@@ -1080,19 +1162,21 @@ const sourceLines = (
   width: number,
 ): BlockLines => {
   const shown = state.expanded.has(SOURCE_MORE_KEY) ? sources : sources.slice(0, SHOWN_BLOCK_ROWS)
-  const view = { expanded: state.expanded, asked: askedCheckOf(awaiting) }
+  const asked = askedCheckOf(awaiting)
+  const newTone = toneOfRole(TONE_ROLE.new)
   const block: TopBlock = {
     name: TEXTS.sourceHeading,
-    bar: nextBar,
+    count: null,
+    balance: sourceSummaryText(sourceSummaries(sources, now, newTone, asked)),
     markPaint: paint.dim,
     buttonPaint: (text) => text,
     focused: (key) => isFocused(state, key),
     allBold: (key) => buttonsAllBold(state, key),
     countPaint: (text) => text,
     moreKey: SOURCE_MORE_KEY,
+    hidden: Math.max(sources.length - SHOWN_BLOCK_ROWS, 0),
     expanded: state.expanded.has(SOURCE_MORE_KEY),
-    keys: sourceKeys(sources),
-    rows: allBlockRows(sourceItems(shown, now, toneOfRole(TONE_ROLE.new), view), state.expanded, width),
+    rows: allBlockRows(sourceItems(shown, now, newTone, { expanded: state.expanded, asked }), state.expanded, width),
   }
   return blockLinesOf(block, state, TOP_BLOCK.sources, width)
 }
@@ -1105,47 +1189,22 @@ const sourceLinesOf = (
 ): BlockLines | null =>
   sourceBlock && sourceBlock.sources.length > 0 ? sourceLines(sourceBlock, awaiting, state, width) : null
 
-const appointmentLinesOf = (
-  appointments: AppointmentBlock | undefined,
-  state: Selection,
-  width: number,
-): BlockLines | null =>
-  appointments && appointments.rows.length > 0 ? appointmentLines(appointments, state, width) : null
-
 /**
- * The blocks one under the other, `offset` lines below the top of the screen, with one rule between neighbours: the
- * head of an open block is that rule, a folded block gets a plain one above it unless a folded block stands right
- * above (folded blocks share the rule below them), and a plain rule closes the stack. An
- * absent block (null) takes no line and has no hit.
+ * The blocks one under the other, `offset` lines below the top of the screen, a blank line after each, so one stands
+ * between neighbours and one between the last and the lanes. An absent block (null) takes no line and has no hit.
  */
-const stackBlocks = (slots: readonly (BlockLines | null)[], offset: number, width: number): BlockStack => {
+const stackBlocks = (slots: readonly (BlockLines | null)[], offset: number): BlockStack => {
   const lines: string[] = []
   const hits: (BlockHit | null)[] = []
-  let previousFolded = false
   for (const slot of slots) {
-    if (slot && !slot.open && !previousFolded) lines.push(rule(width))
     hits.push(slot && { ...slot.hit, firstLine: offset + lines.length + 1 })
-    if (slot) {
-      lines.push(...slot.lines)
-      previousFolded = !slot.open
-    }
+    if (slot) lines.push(...slot.lines, '')
   }
-  return { lines: lines.length > 0 ? [...lines, rule(width)] : lines, hits }
+  return { lines, hits }
 }
 
 /**
- * A dimmed rule before every section of the body but the first, which shows where one ends; none between two
- * one-line lane blocks (the first `laneCount` sections), so folded lanes stand together as a list.
- */
-const separate = (sections: Frame[], width: number, laneCount: number): Frame[] =>
-  sections.flatMap((frame, index) => {
-    if (index === 0) return [frame]
-    const listed = index < laneCount && frame.lines.length === 1 && sections[index - 1]?.lines.length === 1
-    return listed ? [frame] : [textFrame([rule(width)]), frame]
-  })
-
-/**
- * Why badges may be missing, said beside the clock: no watcher runs, or its state is stale. Nothing while it is live,
+ * Why badges may be missing, said at the right end of the title line: no watcher runs, or its state is stale. Nothing while it is live,
  * or when no lane on screen has a pull request a badge could belong to and no source is marked `ticket`.
  */
 const watchNotice = (
@@ -1157,7 +1216,7 @@ const watchNotice = (
   return watch.kind === WATCH_HEALTH.off ? texts.watcherOff : texts.stale(watch.minutes)
 }
 
-/** `groomed 3d ago` beside the clock, dim, amber once the board is overdue; empty while it is unknown. */
+/** `groomed 3d ago` at the right end of the title line, dim, amber once the board is overdue; empty while it is unknown. */
 const groomedCell = (days: number | null | undefined): string => {
   if (days === null || days === undefined) return ''
   const { text, stale } = groomedText(days)
@@ -1185,6 +1244,57 @@ const laneColumnsOf = (lanes: LaneView[], width: number): LaneColumns => {
   return { name, marks, right: rightOf(phases ? tally : 0), phases, tally }
 }
 
+const reasonInputOf = ({ progress, status, restNote }: LaneView): ReasonInput => ({
+  lane: progress.lane,
+  agent: status.agent,
+  restNote,
+})
+
+/** `1 waits on you · 3 idle`: what waits on you in the tone of what waits, the idle count dim; a part at 0 left out. */
+const lanesBalanceText = (lanes: readonly LaneView[]): string => {
+  const { waitsOnYou, idle } = lanesBalance(lanes.map(reasonInputOf))
+  return [
+    waitsOnYou > 0 ? paintOfRole(TONE_ROLE.waiting)(TEXTS.lanesWaitOnYou(waitsOnYou)) : '',
+    idle > 0 ? paint.dim(TEXTS.lanesIdle(idle)) : '',
+  ]
+    .filter(Boolean)
+    .join(paint.dim(` ${ITEM_SEPARATOR} `))
+}
+
+/**
+ * The lanes at work under the head `▾ Lanes · <n>  <balance>`, open at the start; each lane indented under it, a
+ * blank line after an open lane, none above it, so its row keeps its screen line when it opens and folds under the
+ * mouse; none between folded lanes, so they stand together as a list, a folded lane's task row included. `rows` are
+ * the rows of "Your turn" a resting lane may wait on.
+ */
+const lanesFrame = (lanes: LaneView[], rows: readonly UnblockingRow[], context: LanesContext): Frame => {
+  const { state, width } = context
+  const inner = Math.max(width - LANE_INDENT.length, 1)
+  const columns = laneColumnsOf(lanes, inner)
+  const isOpen = ({ progress, status }: LaneView) => isLaneOpen(state, progress.lane.name, status.agent)
+  const content = () => {
+    const laneList = lanes.flatMap((lane, index) => {
+      const frame = laneBlock(lane, { ...context, width: inner }, columns, laneReason(reasonInputOf(lane), rows))
+      const previous = lanes[index - 1]
+      return previous && isOpen(previous) ? [textFrame(['']), frame] : [frame]
+    })
+    return indented(joinFrames(laneList), LANE_INDENT)
+  }
+  const head = {
+    name: TEXTS.lanesHeading,
+    count: lanes.length,
+    balance: lanesBalanceText(lanes),
+    countPaint: unpainted,
+  }
+  return bodyBlock(LANES_KEY, head, isLanesOpen(state), content, { state, width })
+}
+
+/** The status each lane's agent reports, by the lane's name, for the footer's click hint. */
+const agentOfLanes =
+  (lanes: readonly LaneView[]): AgentOf =>
+  (name) =>
+    lanes.find(({ progress }) => progress.lane.name === name)?.status.agent ?? null
+
 /** The lanes by what the view does with them; closed lanes are in none of the three groups. */
 const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAgent', LaneView[]> => {
   const standing = (wanted: LaneStanding) => lanes.filter((lane) => laneStanding(lane) === wanted)
@@ -1216,72 +1326,65 @@ const emphasisedAt = (
 }
 
 /**
- * Title and clock on top, the key hint at the bottom (with the legend after `?`), and in between one
- * block per lane: the lane line with its total bar, and for an open lane the phase rows. Folded lanes are
- * one line each, and a dimmed rule stands between lane blocks unless both are one line. Lanes that wait and
- * lanes with a worktree but no agent each share a closing block; finished lanes are not drawn.
+ * The title on top, no clock (it would change the frame every minute and reset the refresh pace), then the blocks "Your turn" and "Sources"; the body below them scrolls: "Lanes" with one
+ * line per lane at work and an open lane's children, "Waiting" for the lanes not started, the lanes with a worktree
+ * but no agent, and the "Backlog"; a blank line between neighbouring blocks, none inside one. At the bottom what a
+ * click does on the focused row, else the key hint, and the legend after `?`. Finished lanes are not drawn.
  */
 export const renderScreen = (
   {
     title,
-    time,
     lanes,
     planned,
     watch,
     watchesTickets,
     awaiting = [],
-    next,
-    appointments,
+    yourTurn,
     sourceBlock,
     groomedDays,
     unplaced = [],
+    shimmer,
   }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
+  const taskStyle = shimmer ? SHIMMERING_TASK : STILL_TASK
   const { active, waiting, noAgent } = partitionLanes(lanes)
-  const parked = [...waitingBlock(waiting, width), ...parkedBlock(noAgent, width)]
-  const columns = laneColumnsOf(active, width)
   const badgeTexts = BADGE_TEXTS
-  const blocks = active.map((lane) => laneBlock(lane, state, width, columns, badgeTexts))
+  const turnRowsOf = yourTurn ? [...yourTurn.turn.now, ...yourTurn.turn.planned] : []
   const notice = watchNotice({ lanes: active, watch, watchesTickets }, badgeTexts)
-  const clock = [notice ? paint.yellow(notice) : '', groomedCell(groomedDays), paint.dim(time)]
-    .filter(Boolean)
-    .join(COLUMN_SEPARATOR)
-  const titleLine = spread(`${HEADER_MARK} ${paint.bold(title)}`, clock, width)
-  const forYou = awaiting.length > 0 ? waitingLines(awaiting, state, width) : null
-  const queued = next ? nextLines(next, state, width) : null
-  const dated = appointmentLinesOf(appointments, state, width)
-  const nowLines = unplaced.map((task) => nowLine(task, width))
+  const status = [notice ? paint.yellow(notice) : '', groomedCell(groomedDays)].filter(Boolean).join(COLUMN_SEPARATOR)
+  const titleLine = spread(`${HEADER_MARK} ${paint.bold(title)}`, status, width)
+  const turn = yourTurn ? yourTurnLines(yourTurn, state, width) : null
+  const nowLines = unplaced.map((task) => nowLine(task, width, taskStyle))
   const above = nowLines.length > 0 ? [titleLine, rule(width), ...nowLines] : [titleLine]
   const listed = sourceLinesOf(sourceBlock, awaiting, state, width)
-  const stack = stackBlocks([forYou, queued, dated, listed], above.length, width)
-  const endsWithRule = stack.lines.length > 0 || nowLines.length === 0
+  const stack = stackBlocks([turn, listed], above.length)
   const sections = [
-    ...blocks,
-    ...(parked.length > 0 ? [textFrame(parked)] : []),
-    ...(planned.length > 0 ? [plannedFrame(planned, state, width)] : []),
+    ...(active.length > 0 ? [lanesFrame(active, turnRowsOf, { state, width, badgeTexts, taskStyle })] : []),
+    ...(waiting.length > 0 ? [waitingFrame(waiting, state, width)] : []),
+    textFrame(parkedBlock(noAgent, width)),
+    ...(planned.length > 0 ? [backlogFrame(planned, state, width)] : []),
   ]
-  const lead = !endsWithRule && blocks.length === 0 && sections.length > 0 ? [textFrame([rule(width)])] : []
-  const plainHeader = [...above, ...(stack.lines.length > 0 || nowLines.length > 0 ? stack.lines : [rule(width)])]
-  const plainBody = joinFrames([...lead, ...separate(sections, width, blocks.length)])
+  const plainHeader = [...above, ...(stack.lines.length > 0 ? stack.lines : [''])]
+  const plainBody = spaced(sections)
   const blockHits = stack.hits.flatMap(focusHitsOfBlock)
   const focusHits = [...blockHits, ...focusHitsOfTargets(plainBody.targets, plainHeader.length)]
   const header = emphasisedAt(plainHeader, 0, focusHits, state, width)
   const body = { ...plainBody, lines: emphasisedAt(plainBody.lines, plainHeader.length, focusHits, state, width) }
   return {
-    waitingBlock: stack.hits[0],
-    nextBlock: stack.hits[1],
-    appointmentBlock: stack.hits[2],
-    sourceBlock: stack.hits[3],
-    focusHits,
+    yourTurnBlock: stack.hits[0],
+    sourceBlock: stack.hits[1],
+    focusHits: state.showLegend ? focusHits.filter(({ line }) => line < plainHeader.length) : focusHits,
     rowKeys: [...blockHits.map(({ key }) => key), ...targetKeys(body.targets)],
     header,
-    body,
+    body: state.showLegend ? textFrame(legendLines(TEXTS.legend, width)) : body,
     footer: [
       rule(width),
-      fit(paint.dim(TEXTS.hint), width),
-      ...(state.showLegend ? TEXTS.legend.flatMap((line) => wrap(line, width)).map(paint.dim) : []),
+      fit(
+        paint.dim(clickHint(state, (key) => blockRowByKey(stack.hits, key), agentOfLanes(active)) ?? TEXTS.hint),
+        width,
+      ),
     ],
   }
 }
@@ -1297,11 +1400,14 @@ export const renderSelected = (overview: OverviewView, selection: Selection, wid
 }
 
 /**
- * The selection with its row resolved against `screen`: a row the screen draws stays, a block row included; else the
- * first row of the body is selected, none when the body has none.
+ * The selection with its row resolved against `screen`: a row the screen draws stays, a block row or head included;
+ * else the first row of the body that is no block head is selected (the first lane), else the first head, none when
+ * the body has no row.
  */
 export const settledSelection = (selection: Selection, screen: Screen): Selection => {
   const kept = selection.selected !== null && screen.rowKeys.includes(selection.selected)
-  const selected = kept ? selection.selected : selectedKey(selection, targetKeys(screen.body.targets))
+  const keys = targetKeys(screen.body.targets)
+  const rows = keys.filter((key) => !isBlockHeadKey(key))
+  const selected = kept ? selection.selected : selectedKey(selection, rows.length > 0 ? rows : keys)
   return selected === selection.selected ? selection : { ...selection, selected }
 }