jackherd 1.10.0 → 1.11.1

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,
@@ -30,6 +32,7 @@ import {
 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'
@@ -44,9 +47,20 @@ import {
 } from './layout-phase'
 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,
@@ -61,16 +75,22 @@ import {
 } 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 { BADGE_TEXTS, type BadgeTexts, checksText, laneMarkText, TEXTS } from './texts'
+import { paintOfRole, paintOfTone, toneOfRole } from './tones'
 import {
   APPOINTMENT_MORE_KEY,
-  ASK_BUTTON,
+  allBlockRows,
   type BlockHit,
   type BlockRow,
   blockRows,
+  buttonsText,
   moreKeyOf,
+  NEXT_MORE_KEY,
   SHOWN_BLOCK_ROWS,
+  SOURCE_MORE_KEY,
   WAITING_MARK,
   WAITING_MORE_KEY,
   waitingKeys,
@@ -108,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. */
@@ -121,8 +143,14 @@ 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 open appointments of the board, in a block of their own under the for-you block. */
+  /** 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[]
 }
@@ -137,7 +165,13 @@ export type Screen = {
   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[]
 }
 
 /**
@@ -162,6 +196,12 @@ 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
@@ -207,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> = {
@@ -224,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,
   )
 }
@@ -286,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 =>
@@ -432,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 }
@@ -485,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 => {
@@ -504,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,
 })
 
@@ -537,7 +579,7 @@ 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)] : []),
   ]
@@ -573,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. */
@@ -598,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(' ')
 }
 
 /**
@@ -635,7 +701,7 @@ 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()
 }
 
@@ -673,7 +739,8 @@ const foldedTaskRow = (view: LaneView, indent: string, width: number): string[]
 
 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)
@@ -830,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 })
 }
 
@@ -841,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,
@@ -851,7 +918,7 @@ 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 => STATUS_PAINT[AGENT_STATUS.blocked](WAITING_MARK)
+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)
@@ -866,8 +933,10 @@ const blockHead = (name: string, count: number, width: number, countPaint: (text
   return `${lead}${countPaint(String(count))} ${paint.dim(RULE.repeat(Math.max(width - used, 0)))}`
 }
 
-const markedLine = (line: string, row: BlockRow, markPaint: (text: string) => string): string =>
-  line.startsWith(row.mark) ? `${markPaint(row.mark)}${line.slice(row.mark.length)}` : 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 => {
@@ -880,14 +949,23 @@ const dimmedRest = (text: string, from: number): string => {
  * 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 blockRowLines = ({ bar, markPaint }: TopBlock, row: BlockRow): string[] =>
-  row.lines.map((line, index) => {
-    const withButton = index === 0 && row.askColumn !== null
+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 text = withButton ? `${marked}${markPaint(ASK_BUTTON)}` : marked
-    return `${bar()} ${row.url ? link(row.url, text) : text}`
+    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 => {
@@ -913,7 +991,7 @@ const openBlockLines = (block: TopBlock, width: number): BlockLines => {
     open: true,
     lines: [
       blockHead(block.name, count, width, count > 0 ? block.countPaint : (text) => text),
-      ...block.rows.flatMap((row) => blockRowLines(block, row)),
+      ...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 },
@@ -933,8 +1011,11 @@ const waitingLines = (waiting: readonly WaitingItem[], state: Selection, width:
   const block: TopBlock = {
     name: TEXTS.waitingHeading,
     bar: waitingBar,
-    markPaint: STATUS_PAINT[AGENT_STATUS.blocked],
-    countPaint: STATUS_PAINT[AGENT_STATUS.blocked],
+    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,
@@ -950,6 +1031,9 @@ const appointmentLines = ({ rows }: AppointmentBlock, state: Selection, width: n
     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),
@@ -959,6 +1043,68 @@ const appointmentLines = ({ rows }: AppointmentBlock, state: Selection, width: n
   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,
@@ -1011,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
 
@@ -1042,6 +1195,26 @@ 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
@@ -1049,7 +1222,20 @@ const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAge
  * 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 = [], appointments, unplaced = [] }: OverviewView,
+  {
+    title,
+    time,
+    lanes,
+    planned,
+    watch,
+    watchesTickets,
+    awaiting = [],
+    next,
+    appointments,
+    sourceBlock,
+    groomedDays,
+    unplaced = [],
+  }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
@@ -1059,13 +1245,17 @@ 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 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 stack = stackBlocks([forYou, dated], above.length, width)
+  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,
@@ -1073,11 +1263,21 @@ export const renderScreen = (
     ...(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 {
     waitingBlock: stack.hits[0],
-    appointmentBlock: stack.hits[1],
-    header: [...above, ...(stack.lines.length > 0 || nowLines.length > 0 ? stack.lines : [rule(width)])],
-    body: joinFrames([...lead, ...separate(sections, width, blocks.length)]),
+    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),
@@ -1092,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 }
 }

package/src/plans/link-chips.ts

@@ -1,4 +1,4 @@
-import type { LinkKind } from '../config/link-kinds'
+import { ARTIFACT_LINK_KIND, type LinkKind } from '../config/link-kinds'
 
 /** A link of a plan that matches a link kind, as the sprint page shows it. */
 export type LinkChip = { url: string; label: string; icon: string; private: boolean }
@@ -27,9 +27,27 @@ const linksOf = (line: string): Found[] => {
   return found.sort((left, right) => line.indexOf(left.url) - line.indexOf(right.url))
 }
 
-const labelOf = ({ text, before }: Found, kind: LinkKind): string => {
-  const written = text ?? LABEL_BEFORE.exec(before)?.[1]
-  return written ? written.replace(MARKS, '').replace(CONTROL, '').trim() || kind.label : kind.label
+const LIST_LEAD = /^\s*(?:[-*>]\s*)*(?:\[[ xX]\]\s*)?/
+const LEFTOVER_LINK = /\bhttps?:\/\/\S+/g
+const TITLE_END = /[\s:,;.\-–>]+$/
+
+/** What a line says besides its links, without list marks, checkbox and emphasis: the title of a bare artifact link. */
+const lineTitleOf = ({ line }: Found): string =>
+  line
+    .replace(MARKDOWN_LINK, '$1')
+    .replace(AUTOLINK, '')
+    .replace(LEFTOVER_LINK, '')
+    .replace(LIST_LEAD, '')
+    .replace(MARKS, '')
+    .replace(CONTROL, '')
+    .replace(TITLE_END, '')
+    .trim()
+
+const labelOf = (found: Found, kind: LinkKind): string => {
+  const written = found.text ?? LABEL_BEFORE.exec(found.before)?.[1]
+  const own = written?.replace(MARKS, '').replace(CONTROL, '').trim()
+  if (own) return own
+  return (kind.pattern === ARTIFACT_LINK_KIND.pattern && lineTitleOf(found)) || kind.label
 }
 
 /**