jackherd 1.9.0 → 1.11.0

package/src/plans/layout.ts

@@ -1,3 +1,4 @@
+import { TONE_ROLE } from '../config/tones'
 import { CONTEXT_LEVEL, type ContextLevel, type ContextReading, contextLabel } from '../context'
 import type { LaneProgress, PhaseProgress } from '../plan-format'
 import { currentPhase, isPhaseOpen, phaseLabel } from '../plan-format'
@@ -8,6 +9,7 @@ import {
   badge,
   bar,
   box,
+  bracket,
   fit,
   link,
   packGroups,
@@ -17,7 +19,7 @@ import {
   visibleLength,
   wrap,
 } from '../terminal/text'
-import { AGENT_STATUS, type AgentStatus, isAgentStatus } from '../terminal/types'
+import { AGENT_STATUS, type AgentStatus, isAgentStatus, isRestingAgent } from '../terminal/types'
 import { textWidth } from '../terminal/width'
 import {
   NO_BADGES,
@@ -28,7 +30,9 @@ 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 { groomedText } from './groomed'
 import { LANE_STANDING, type LaneStanding, laneStanding, waitingNote } from './lane-standing'
 import { type LaneSummary, laneSummary } from './lane-summary'
 import { type LaneTickets, withoutTicketKey } from './lane-tickets'
@@ -41,25 +45,57 @@ import {
   nowLine,
   plain,
 } from './layout-phase'
-import { summaryChildren } from './layout-summary'
+import { foldedTaskLine, summaryChildren } from './layout-summary'
 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, phaseList, plannedPhaseCount } from './planned'
+import { type PlannedPlan, plannedNextLabel } from './planned'
 import { CHECKS, type ChecksState, failedTestKey, type PullRequest, pullRequestKey } from './pull-requests'
+import {
+  boldBracketAt,
+  buttonsAllBold,
+  type FocusHit,
+  focusHitsOfBlock,
+  focusHitsOfTargets,
+  focusLine,
+  isFocused,
+  LINKS_KEY_PREFIX,
+} from './row-focus'
 import {
   type ClickTarget,
+  isBlockFolded,
   isLaneOpen,
   laneKey,
   PLANNED_KEY,
   type Selection,
   selectedKey,
+  TOP_BLOCK,
+  type TopBlockId,
   targetKeys,
 } from './selection'
 import type { SentChip } from './sent-files'
 import { shownWithMore } from './shown-with-more'
-import { chevronOf, NO_AGENT_SYMBOL, statusSymbol, statusWord } from './symbols'
+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 { BADGE_TEXTS, type BadgeTexts, checksText, laneMarkText, TEXTS } from './texts'
-import { SHOWN_WAITING, WAITING_MARK, type WaitingRow, waitingRows } from './waiting-click'
+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'
 
 /**
  * Where a lane stands outside its plan. `agent` is the terminal adapter's status, null when no agent is listed;
@@ -92,6 +128,8 @@ export type LaneView = {
   models?: Record<string, PhaseModel>
   /** The files this lane's session sent to the user, shown as badges on the row of link chips. */
   sentFiles?: SentChip[]
+  /** What a resting lane waits on, from its report (`restNote`); absent or null while it works or asks nothing. */
+  restNote?: string | null
 }
 
 /** `watch` is the health of the watcher the badges come from, absent when it was not read. */
@@ -105,13 +143,36 @@ export type OverviewView = {
   watchesTickets?: boolean
   /** The open items of the board's section of what waits on the user, shown under the title. */
   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. */
+  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[]
 }
 
-/** A fixed header and footer around a body that scrolls; body lines and targets count from the body's top. */
-/** The drawn screen; `waitingLine` is the screen line (0-based) of the first for-you row, where a click is matched. */
-export type Screen = { header: string[]; body: Frame; footer: string[]; waitingLine: number }
+/**
+ * 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.
+ */
+export type Screen = {
+  header: string[]
+  body: Frame
+  footer: string[]
+  waitingBlock: BlockHit | null
+  nextBlock: BlockHit | null
+  appointmentBlock: 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[]
+  /** The keys of the rows the arrows walk, in screen order: the rows of the blocks on top, then those of the body. */
+  rowKeys: string[]
+}
 
 /**
  * Widths shared by every lane line: the name column, the folded pull request badges, and bar with context. They are
@@ -121,8 +182,38 @@ export type Screen = { header: string[]; body: Frame; footer: string[]; waitingL
  */
 type LaneColumns = { name: number; marks: number; right: number; phases: boolean; tally: number }
 
+/**
+ * The lines of a block on top of the herd; the head of an open one is a rule of its own, a folded one is a plain line.
+ * `hit` is what a click on it is matched against, without the screen line the stack gives it.
+ */
+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.
+ */
+type TopBlock = {
+  name: string
+  bar: () => 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. */
+  buttonPaint: (text: string) => string
+  /** Whether a row is the selected one or under the mouse: it gets the background, the mark, and bold 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. */
+  countPaint: (text: string) => string
+  moreKey: string
+  expanded: boolean
+  keys: readonly string[]
+  rows: BlockRow[]
+}
+
+/** 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)[] }
+
 const BRANCH_MARK = '⎇'
-const WOOF = 'woof'
 const SENT_MARK = '📎'
 const SYMBOL_WIDTH = 2
 const NAME_WIDTH_MAX = 24
@@ -140,7 +231,7 @@ 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 (D96), and where the trunk
+ * 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 = '  '
@@ -156,12 +247,10 @@ const TEST_PATH_LEVEL = ' > '
 const TEST_PATH_SEPARATOR = ' › '
 const PLACE_SEPARATOR = ' · '
 
-/** The colour of a lane state, word and symbol alike: teal while working or done, bold amber when it waits for you, grey when idle. */
-const STATUS_PAINT: Record<AgentStatus, (text: string) => string> = {
-  [AGENT_STATUS.working]: paint.teal,
-  [AGENT_STATUS.blocked]: (text) => paint.bold(paint.yellow(text)),
-  [AGENT_STATUS.done]: paint.teal,
-  [AGENT_STATUS.idle]: paint.dim,
+/** The colour of a lane state, word and symbol alike: the tone of `running` while working or done, bold `waiting` when it waits for you, `resting` when idle. */
+const statusPaint = (status: AgentStatus): ((text: string) => string) => {
+  if (status === AGENT_STATUS.blocked) return (text) => paint.bold(paintOfRole(TONE_ROLE.waiting)(text))
+  return status === AGENT_STATUS.idle ? paintOfRole(TONE_ROLE.resting) : paintOfRole(TONE_ROLE.running)
 }
 
 const CHECKS_PAINT: Record<ChecksState, (text: string) => string> = {
@@ -173,13 +262,13 @@ const CHECKS_PAINT: Record<ChecksState, (text: string) => string> = {
 
 /** Only a blocked agent is named in the lane line, since there the user must act; the symbol says the rest. */
 const agentLabel = (agent: string | null): string =>
-  agent === AGENT_STATUS.blocked ? STATUS_PAINT[AGENT_STATUS.blocked](statusWord(agent)) : ''
+  agent === AGENT_STATUS.blocked ? statusPaint(AGENT_STATUS.blocked)(statusWord(agent)) : ''
 
 /** The symbol of a status padded to `SYMBOL_WIDTH` cells, so the names after it start in one column. */
 const symbolCell = (agent: string | null): string => {
   const symbol = statusSymbol(agent)
   return padVisible(
-    agent !== null && isAgentStatus(agent) ? STATUS_PAINT[agent](symbol) : paint.dim(symbol),
+    agent !== null && isAgentStatus(agent) ? statusPaint(agent)(symbol) : paint.dim(symbol),
     SYMBOL_WIDTH,
   )
 }
@@ -189,12 +278,11 @@ const aheadLabel = ({ branch, ahead }: LaneStatus): string => {
   return ahead > 0 ? paint.teal(`↑${ahead}`) : ''
 }
 
+const branchLabel = (status: LaneStatus): string =>
+  status.branch ? paint.dim(`${BRANCH_MARK} ${status.branch}`) : paint.dim(TEXTS.noWorktree)
+
 const gitLabel = (status: LaneStatus): string =>
-  [
-    status.branch ? paint.dim(`${BRANCH_MARK} ${status.branch}`) : paint.dim(TEXTS.noWorktree),
-    aheadLabel(status),
-    status.dirty ? paint.magenta(`±${status.dirty}`) : '',
-  ]
+  [branchLabel(status), aheadLabel(status), status.dirty ? paint.magenta(`±${status.dirty}`) : '']
     .filter(Boolean)
     .join(' ')
 
@@ -236,9 +324,9 @@ export const rowWithCount = (
 const fitsBeside = (head: string, cells: BadgeCell[], width: number): boolean =>
   visibleLength(head) + packedWidth(cells) + COLUMN_SEPARATOR.length + MIN_TITLE_WIDTH <= width
 
-/** The number of a pull request as a badge linked to it, padded to its column. */
+/** The number of a pull request as a bracket button linked to it, padded to its column. */
 const numberCell = (pullRequest: PullRequest): string =>
-  padVisible(badge(pullRequest.url, `↗ #${pullRequest.number}`), PULL_REQUEST_BADGE_WIDTH)
+  padVisible(bracket(pullRequest.url, `↗ #${pullRequest.number}`), PULL_REQUEST_BADGE_WIDTH)
 
 /** The column the check chip of a pull request row starts in, behind its number. */
 const checksColumnOf = (pullRequest: PullRequest): number =>
@@ -247,7 +335,7 @@ const checksColumnOf = (pullRequest: PullRequest): number =>
 /**
  * `⟦↗ #<number>⟧  ✓ checks  ⟦🌐 preview⟧ ⟦💬 3 new⟧  title`: the number as a badge and the check state in fixed
  * columns, the watcher's badges after them and the title last, cut with `…` on its one line. When the badges leave no
- * room for a title, they go on lines of their own below, starting in the column of the lane's status symbol (D96).
+ * room for a title, they go on lines of their own below, starting in the column of the lane's status symbol.
  */
 const pullRequestRow = (pullRequest: PullRequest, context: LaneContext): Frame => {
   const number = numberCell(pullRequest)
@@ -382,16 +470,18 @@ const progressColumn = ({ done, total, phasesDone, phases }: LaneSummary['tally'
   return `${counts}${paint.dim(phaseCount)}`
 }
 
-const CHIP_GAP = ' '
+const CHIP_GAP = '  '
+/** The most cells the label of a link chip takes in its bracket; a longer title is cut with an ellipsis. */
+const CHIP_LABEL_WIDTH = 24
 
 const TICKET_MARK = '📡'
 const STATUS_SEPARATOR = ' · '
 /** Between the checkbox count and the phase count of a lane. */
 const TALLY_SEPARATOR = ' · '
 
-/** `✦ label` as a badge linked to the chip's address, `private` faint after it for a link its plan says is private. */
+/** `[✦ 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 =>
-  badge(url, `${icon} ${plain(label)}`, hidden ? TEXTS.privateLink : '')
+  bracket(url, `${icon} ${fit(plain(label), CHIP_LABEL_WIDTH)}`, 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 }
@@ -435,9 +525,11 @@ const packedFrame = (cells: BadgeCell[], lead: string, width: number): Frame =>
 
 const ticketTone = (isNew: boolean): BadgeTone => (isNew ? BADGE_TONE.amber : BADGE_TONE.grey)
 
-/** A badge linked to `url`, or a box no click opens when there is none. */
-const linkedBox = (url: string | null, text: string, tone: BadgeTone): string =>
-  url ? badge(url, text, '', tone) : box(text, tone)
+/** A bracket button linked to `url` where nothing is new, a badge in the tone of what is, a box no click opens without `url`. */
+const linkedBox = (url: string | null, text: string, tone: BadgeTone): string => {
+  if (!url) return box(text, tone)
+  return tone === BADGE_TONE.grey ? bracket(url, text) : badge(url, text, '', tone)
+}
 
 /** `📡 T-1 · In Progress` linked to the ticket, amber while new; a ticket without URL is a box no click opens. */
 const ticketCell = ({ id, url, status, isNew }: TicketBadge): BadgeCell => {
@@ -454,7 +546,7 @@ const ticketCells = (tickets: LaneTickets | null): BadgeCell[] => {
 
 /** A file the lane's session sent to the user, `📎 name` linked by its `file:` address; the terminal opens it, no click of ours does. */
 const sentCell = ({ url, label }: SentChip): BadgeCell => ({
-  cell: badge(url, `${SENT_MARK} ${plain(label)}`),
+  cell: bracket(url, `${SENT_MARK} ${plain(label)}`),
   key: null,
 })
 
@@ -474,7 +566,7 @@ const chipCells = (chips: LinkChip[], tickets: LaneTickets | null, sent: readonl
 
 /**
  * `🌐 preview` opening the preview, `💬 <n> new` in amber opening the pull request, and `✋ changes requested` in dark
- * red opening it too, each only when there is one (D96).
+ * red opening it too, each only when there is one.
  */
 const badgeCells = (
   pullRequest: PullRequest,
@@ -487,22 +579,24 @@ const badgeCells = (
     key: chipKey(pullRequest.url),
   })
   return [
-    ...(badges.preview ? [{ cell: badge(badges.preview, texts.preview), key: chipKey(badges.preview) }] : []),
+    ...(badges.preview ? [{ cell: bracket(badges.preview, texts.preview), key: chipKey(badges.preview) }] : []),
     ...(badges.feedback > 0 ? [onPullRequest(texts.feedback(badges.feedback), BADGE_TONE.amber)] : []),
     ...(badges.changesRequested ? [onPullRequest(texts.changesRequested, BADGE_TONE.red)] : []),
   ]
 }
 
 /**
- * The phase the lane line names: the open phase moved last, else the lane's current phase while it is open; never one
- * ticked to the end, whose state the `✓` line says (`not merged`). Null when there is neither.
+ * The phase the lane line names: the one its report or branch signals, else the open phase moved last, else the
+ * lane's current phase while it is open; never one ticked to the end, whose state the `✓` line says. Null when there
+ * is none.
  */
 const headPhase = (view: LaneView): PhaseProgress | null => {
+  const { signalled, latest } = summaryOf(view)
   const current = currentPhase(view.progress)
-  return summaryOf(view).latest ?? (current && isPhaseOpen(current) ? current : null)
+  return signalled ?? latest ?? (current && isPhaseOpen(current) ? current : null)
 }
 
-/** `P9 Freigabe 0.x` for the phase the lane line names; empty when there is none. */
+/** `P9 Release 1.0` for the phase the lane line names; empty when there is none. */
 const nextPhaseLabel = (view: LaneView): string => {
   const phase = headPhase(view)
   return phase ? `${phaseLabel(phase.id)}${phase.title ? ` ${plain(phase.title)}` : ''}` : ''
@@ -521,7 +615,7 @@ const pullRequestMark = (pullRequest: PullRequest, badges: WatchBadges): string
   const found = badges[String(pullRequest.number)] ?? NO_BADGES
   const feedback = found.feedback > 0 ? ` 💬 ${found.feedback}` : ''
   const text = `↗ #${pullRequest.number}${feedback}${found.changesRequested ? ' ✋' : ''}`
-  return badge(pullRequest.url, text, '', markTone(found))
+  return linkedBox(pullRequest.url, text, markTone(found))
 }
 
 /** `📡 <n>` in amber while tickets of the lane are new, linked to the first of them; nothing otherwise. */
@@ -546,11 +640,35 @@ 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. */
+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 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.
+ */
+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 markText = laneMarkText(view)
   const marker = markText ? paint.yellow(markText) : ''
-  return [agentLabel(view.status.agent), marker, open ? '' : foldedPhaseLabel(view)].filter(Boolean).join(' ')
+  const phase = restsFolded(view, open) ? restDetail(view) : open ? '' : foldedPhaseLabel(view)
+  return [agentLabel(view.status.agent), marker, phase].filter(Boolean).join(' ')
 }
 
 /**
@@ -583,14 +701,14 @@ const laneProgressColumn = (view: LaneView, tallyWidth: number): string => {
 
 /** Context and bar at the right edge of a folded lane line, as wide as the lane has them. */
 const laneRight = (view: LaneView, tallyWidth: number): string => {
-  const counts = laneProgressColumn(view, tallyWidth)
+  const counts = restsFolded(view, false) ? '' : laneProgressColumn(view, tallyWidth)
   return counts ? `${contextCell(view.context)}${counts}` : contextCell(view.context).trimEnd()
 }
 
 /** The cells of the phase count column, 0 when the pane leaves it out. */
 const tallyWidthOf = ({ phases, tally }: LaneColumns): number => (phases ? tally : 0)
 
-/** A folded lane's marks in the column of `columns.marks`, right before context and bar (D96). */
+/** A folded lane's marks in the column of `columns.marks`, right before context and bar. */
 const markedRight = (view: LaneView, columns: LaneColumns): string => {
   const right = laneRight(view, tallyWidthOf(columns))
   const marks = laneMarks(view)
@@ -602,7 +720,7 @@ const markedRight = (view: LaneView, columns: LaneColumns): string => {
 
 /**
  * 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 (17:40), as the branches of an open lane do; an open lane keeps its trunk in front.
+ * 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)
@@ -610,19 +728,31 @@ const detailIndent = (open: boolean, nameColumn: number): string => {
   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[] => {
+  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)
+  return line ? [line] : []
+}
+
 const laneLines = (view: LaneView, open: boolean, width: number, columns: LaneColumns): string[] => {
   const { progress, status } = view
-  const cells = padVisible(paint.bold(fit(progress.lane.name, columns.name)), columns.name)
+  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)
-  return withDetail(head, laneDetail(view, open), right, width, detailIndent(open, nameColumn))
+  const lines = withDetail(head, laneDetail(view, open), right, width, detailIndent(open, nameColumn))
+  return open ? lines : [...lines, ...foldedTaskRow(view, ' '.repeat(nameColumn), width)]
 }
 
 /** 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; context: string } => {
+const sessionParts = (view: LaneView): { left: string; git: string; branch: string; context: string } => {
   const git = gitLabel(view.status)
-  return { left: view.sessionTitle ? plain(view.sessionTitle) : git, git, context: contextValue(view.context) }
+  const branch = branchLabel(view.status)
+  return { left: view.sessionTitle ? plain(view.sessionTitle) : git, git, branch, context: contextValue(view.context) }
 }
 
 /**
@@ -631,31 +761,36 @@ const sessionParts = (view: LaneView): { left: string; git: string; context: str
  * title cut. Without a title the branch stands at the left.
  */
 const sessionLine = (view: LaneView, width: number): string => {
-  const { left, git, context } = sessionParts(view)
+  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 withGit = visibleLength(left) + COLUMN_SEPARATOR.length + visibleLength(git) <= room
-  const right = [withGit ? git : '', context].filter(Boolean).join(COLUMN_SEPARATOR)
+  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)
 }
 
 /**
  * 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, the branch giving way first; without a title the branch at the left and the chip at the right. Null when
- * the line has no room for the chip beside the whole title, and the chip keeps its row of chips.
+ * 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.
  */
 const sessionWithChip = (view: LaneView, chip: BadgeCell, width: number): Frame | null => {
-  const { left, git, context } = sessionParts(view)
+  const { left, git, branch, context } = sessionParts(view)
   const tails = view.sessionTitle
     ? [
         [chip.cell, git, context],
-        [chip.cell, context],
+        [chip.cell, branch, context],
       ]
     : [[chip.cell, context]]
-  const right = tails
-    .map((tail) => tail.filter(Boolean).join(COLUMN_SEPARATOR))
-    .find((candidate) => visibleLength(left) + COLUMN_SEPARATOR.length + visibleLength(candidate) <= width)
-  if (right === undefined) return null
+  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 }
@@ -762,9 +897,9 @@ const parkedBlock = (lanes: LaneView[], width: number): string[] => {
  */
 const plannedFrame = (planned: PlannedPlan[], state: Selection, width: number): Frame => {
   if (planned.length === 0) return textFrame([])
-  const phases = plannedPhaseCount(planned)
   const open = state.expanded.has(PLANNED_KEY)
-  const head = [paint.dim(fit(`${chevronOf(open)} ${TEXTS.planned(phases, planned.length)}`, width))]
+  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 })
 }
 
@@ -773,7 +908,7 @@ const plannedRows = (planned: PlannedPlan[], width: number, indent: string): str
   planned.map((plan) =>
     rowWithCount(
       indent,
-      `${plain(plan.title)} · ${phaseList(plan)}`,
+      `${plain(plan.title)} · ${plannedNextLabel(plan)}`,
       countCell('', countText(plan.done, plan.total)),
       width,
       paint.dim,
@@ -782,32 +917,232 @@ const plannedRows = (planned: PlannedPlan[], width: number, indent: string): str
 
 const rule = (width: number): string => paint.dim(RULE.repeat(width))
 
-/** The rule under the for-you block, labelled woof (Jack barks) so the block reads as a section of its own. */
-const barkingRule = (width: number): string => {
-  const lead = `${RULE.repeat(2)} ${WOOF} `
-  return paint.dim(`${lead}${RULE.repeat(Math.max(width - textWidth(lead), 0))}`)
+/** 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 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.
+ */
+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)))}`
 }
 
-/** One row as lines: a dim bar and the text in bold on each, linked when the row has an address. */
-const waitingRowLines = ({ lines, url }: WaitingRow): string[] =>
-  lines.map((line) => `${paint.dim(WAITING_MARK)} ${paint.bold(url ? link(url, line) : line)}`)
+const markedLine = (line: string, row: BlockRow, markPaint: (text: string) => string): string => {
+  const paintMark = row.tone ? paintOfTone(row.tone) : markPaint
+  return line.startsWith(row.mark) ? `${paintMark(row.mark)}${line.slice(row.mark.length)}` : line
+}
+
+/** The text from `from` on dimmed, without the blanks that pad it to the right edge. */
+const dimmedRest = (text: string, from: number): string => {
+  const end = text.trimEnd().length
+  return from >= end ? text : `${text.slice(0, from)}${paint.dim(text.slice(from, end))}${text.slice(end)}`
+}
 
 /**
- * What waits on the user's answer, on top of the herd until it is closed: `▌ 📎 name` for a sent file or an Artifact
- * and `▌ ? question` for a question of the board, up to five and `▌ +<n>` for the rest. A row wider than the pane is
- * cut to one line; once expanded it wraps over several.
+ * 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.
  */
-const waitingLines = (waiting: readonly WaitingItem[], expanded: ReadonlySet<string>, width: number): string[] => {
-  const more = Math.max(waiting.length - SHOWN_WAITING, 0)
-  return [
-    ...waitingRows(waiting, expanded, width).flatMap(waitingRowLines),
-    ...(more > 0 ? [`${paint.dim(WAITING_MARK)} +${more}`] : []),
-  ]
+const blockRowLines = (
+  { bar, 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 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}`
+    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 },
+  }
+}
+
+/**
+ * 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.
+ */
+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}`
+  return {
+    open: true,
+    lines: [
+      blockHead(block.name, count, width, count > 0 ? block.countPaint : (text) => text),
+      ...block.rows.flatMap((row) => blockRowLines(block, row, width)),
+      ...(more > 0 ? [`${block.bar()} ${moreLine}`] : []),
+    ],
+    hit: { rows: block.rows, moreKey: moreKeyOf(count, block.moreKey), keys: block.keys },
+  }
 }
 
-/** A dimmed rule before every lane block but the first, folded or open: it shows where one lane ends. */
-const separate = (blocks: Frame[], width: number): Frame[] =>
-  blocks.flatMap((frame, index) => (index === 0 ? [frame] : [textFrame([rule(width)]), frame]))
+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)
+}
+
+/** 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)
+}
+
+/** 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 next block names nothing queued in one dim line, which has no rows to click. */
+const emptyNextLines = (): BlockLines => ({
+  open: false,
+  lines: [paint.dim(`${TEXTS.nextHeading} ${ITEM_SEPARATOR} ${TEXTS.nextEmpty}`)],
+  hit: { rows: [], moreKey: null, keys: [] },
+})
+
+/** 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()
+  const block: TopBlock = {
+    name: TEXTS.nextHeading,
+    bar: nextBar,
+    markPaint: paint.dim,
+    buttonPaint: (text) => text,
+    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),
+  }
+  return blockLinesOf(block, state, TOP_BLOCK.next, 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. */
+const sourceLines = (
+  { sources, now }: SourceBlock,
+  awaiting: readonly WaitingItem[],
+  state: Selection,
+  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 block: TopBlock = {
+    name: TEXTS.sourceHeading,
+    bar: nextBar,
+    markPaint: paint.dim,
+    buttonPaint: (text) => text,
+    focused: (key) => isFocused(state, key),
+    allBold: (key) => buttonsAllBold(state, key),
+    countPaint: (text) => text,
+    moreKey: SOURCE_MORE_KEY,
+    expanded: state.expanded.has(SOURCE_MORE_KEY),
+    keys: sourceKeys(sources),
+    rows: allBlockRows(sourceItems(shown, now, toneOfRole(TONE_ROLE.new), view), state.expanded, width),
+  }
+  return blockLinesOf(block, state, TOP_BLOCK.sources, width)
+}
+
+const sourceLinesOf = (
+  sourceBlock: SourceBlock | undefined,
+  awaiting: readonly WaitingItem[],
+  state: Selection,
+  width: number,
+): 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.
+ */
+const stackBlocks = (slots: readonly (BlockLines | null)[], offset: number, width: 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
+    }
+  }
+  return { lines: lines.length > 0 ? [...lines, rule(width)] : 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,
@@ -822,6 +1157,13 @@ 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. */
+const groomedCell = (days: number | null | undefined): string => {
+  if (days === null || days === undefined) return ''
+  const { text, stale } = groomedText(days)
+  return stale ? paint.yellow(text) : paint.dim(text)
+}
+
 /** Chevron, symbol and the gaps around them before the name column of a lane line. */
 const LANE_HEAD_CELLS = 2 + SYMBOL_WIDTH + 1
 
@@ -853,14 +1195,47 @@ const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAge
   }
 }
 
+/**
+ * The line under the mouse as the mouse wants it: a line of links, which is no row of its own, gets the focus
+ * background and mark, and the square-bracket button the mouse is on is bold. `offset` is the screen line `lines` starts at.
+ */
+const emphasisedAt = (
+  lines: string[],
+  offset: number,
+  hits: readonly FocusHit[],
+  { hovered, hoveredFrom }: Selection,
+  width: number,
+): string[] => {
+  const hit = hovered ? hits.find(({ key }) => key === hovered) : undefined
+  const index = hit ? hit.line - offset : -1
+  const line = lines[index]
+  if (line === undefined || !hit) return lines
+  const marked = hit.key.startsWith(LINKS_KEY_PREFIX) ? focusLine(line, width, true) : line
+  const emphasised = hoveredFrom == null ? marked : boldBracketAt(marked, hoveredFrom)
+  return lines.map((each, at) => (at === index ? emphasised : each))
+}
+
 /**
  * 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 every lane block after the first is preceded by a dimmed rule. Lanes that wait and
+ * 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.
  */
 export const renderScreen = (
-  { title, time, lanes, planned, watch, watchesTickets, awaiting = [], unplaced = [] }: OverviewView,
+  {
+    title,
+    time,
+    lanes,
+    planned,
+    watch,
+    watchesTickets,
+    awaiting = [],
+    next,
+    appointments,
+    sourceBlock,
+    groomedDays,
+    unplaced = [],
+  }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
@@ -870,20 +1245,39 @@ export const renderScreen = (
   const badgeTexts = BADGE_TEXTS
   const blocks = active.map((lane) => laneBlock(lane, state, width, columns, badgeTexts))
   const notice = watchNotice({ lanes: active, watch, watchesTickets }, badgeTexts)
-  const clock = notice ? `${paint.yellow(notice)}${COLUMN_SEPARATOR}${paint.dim(time)}` : paint.dim(time)
-  const top = [spread(`${HEADER_MARK} ${paint.bold(title)}`, clock, width), rule(width)]
+  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 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 sections = [
+    ...blocks,
+    ...(parked.length > 0 ? [textFrame(parked)] : []),
+    ...(planned.length > 0 ? [plannedFrame(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 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 {
-    waitingLine: top.length + unplaced.length,
-    header: [
-      ...top,
-      ...unplaced.map((task) => nowLine(task, width)),
-      ...(awaiting.length > 0 ? [...waitingLines(awaiting, state.expanded, width), barkingRule(width)] : []),
-    ],
-    body: joinFrames([
-      ...separate(blocks, width),
-      ...(parked.length > 0 ? [textFrame([rule(width), ...parked])] : []),
-      ...(planned.length > 0 ? [textFrame([rule(width)]), plannedFrame(planned, state, width)] : []),
-    ]),
+    waitingBlock: stack.hits[0],
+    nextBlock: stack.hits[1],
+    appointmentBlock: stack.hits[2],
+    sourceBlock: stack.hits[3],
+    focusHits,
+    rowKeys: [...blockHits.map(({ key }) => key), ...targetKeys(body.targets)],
+    header,
+    body,
     footer: [
       rule(width),
       fit(paint.dim(TEXTS.hint), width),
@@ -898,6 +1292,16 @@ export const renderScreen = (
  */
 export const renderSelected = (overview: OverviewView, selection: Selection, width: number): Screen => {
   const first = renderScreen(overview, selection, width)
-  const selected = selectedKey(selection, targetKeys(first.body.targets))
-  return selected === selection.selected ? first : renderScreen(overview, { ...selection, selected }, width)
+  const settled = settledSelection(selection, first)
+  return settled === selection ? first : renderScreen(overview, settled, width)
+}
+
+/**
+ * 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.
+ */
+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))
+  return selected === selection.selected ? selection : { ...selection, selected }
 }