jackherd 1.10.0 → 1.11.0

package/src/plans/waiting-click.ts

@@ -1,8 +1,10 @@
+import type { ToneName } from '../config/tones'
 import { WAITING_KIND, type WaitingItem } from '../plan-format/waiting'
 import { fit, padVisible, wrap } from '../terminal/text'
 import { textWidth } from '../terminal/width'
 import { ASK_KIND, type AskTarget } from './ask-target'
 import { plain } from './layout-phase'
+import { DONE_KIND, type DoneTarget } from './row-targets'
 import { MOUSE_BUTTON, type MouseEvent } from './selection'
 import { shortTitle } from './task-name'
 
@@ -20,16 +22,31 @@ export type BlockRow = {
   url: string | null
   /** What the coordinator can be asked to put: a dialog question or a row of the board; null for files and appointments. */
   ask: AskTarget | null
-  /** The screen column (1-based) `[ask]` starts in on the first line, five cells wide; null for a row without one. */
-  askColumn: number | null
+  /** The buttons at the right edge of the first line, `[ask]` first, each with the screen column (1-based) it starts in. */
+  buttons: PlacedButton[]
   /** What the folded block shows of the row: the time column, if any, and the short title, without the mark. */
   preview: string
   /** Per line, the index in it where the part behind the short title starts; the line's length where none of it is. */
   dimFrom: number[]
+  /** The tone of the mark when it differs from the block's; absent for most rows. */
+  tone?: ToneName
+  /** The key in the expanded set that a click on the row flips, whatever its text or address; absent for most rows. */
+  toggle?: string
+  /** The row is dim from its text on; absent for most rows. */
+  dim?: boolean
 }
 
-/** What a click does: expand or fold the row (its key), open an address, ask the coordinator to put the row, or nothing (null). */
-export type BlockClick = { toggle: string } | { open: string } | { ask: AskTarget }
+/**
+ * What a click does: expand or fold the row (its key), open an address, ask the coordinator (to put the row to the
+ * user, to run an appointment now, to ask for a new time), close the row (`done`), or nothing (null).
+ */
+export type BlockClick = { toggle: string } | { open: string } | { ask: AskTarget } | { done: DoneTarget }
+
+/** A button of a row: its label as drawn and what a click on it does. */
+export type BlockButton = { label: string; click: BlockClick }
+
+/** A button with the screen column (1-based) its label starts in. */
+export type PlacedButton = BlockButton & { column: number }
 
 /**
  * One row of a block of the herd before it is drawn: the key it expands by, the `mark` that starts it (kept apart so
@@ -45,6 +62,13 @@ export type BlockItem = {
   title?: string
   url: string | null
   ask: AskTarget | null
+  /** The buttons after `[ask]`, in the order they are drawn. */
+  buttons?: readonly BlockButton[]
+  tone?: ToneName
+  /** The key in the expanded set that a click on the row flips, whatever its text or address. */
+  toggle?: string
+  /** The row is dim from its text on (an entry already asked about). */
+  dim?: boolean
 }
 
 /**
@@ -65,12 +89,22 @@ export const SHOWN_BLOCK_ROWS = 5
 export const WAITING_MORE_KEY = 'more>waiting'
 /** The same for the appointment block. */
 export const APPOINTMENT_MORE_KEY = 'more>appointment'
+/** The same for the next block. */
+export const NEXT_MORE_KEY = 'more>next'
+/** The same for the sources block. */
+export const SOURCE_MORE_KEY = 'more>source'
 /** The bar and the blank that start every line of a for-you row. */
 export const WAITING_MARK = '▌'
 
 /** The button at the right edge of a question or a board row; a click on it, and only on it, asks the coordinator. */
 export const ASK_BUTTON = '[ask]'
+/** The button that closes a row: the board row gets its status, a sent file or a question its record. */
+export const DONE_BUTTON = '[done]'
+/** The appointment buttons that ask the coordinator to run the row now, and to ask the user for a new time. */
+export const RUN_BUTTON = '[run]'
+export const MOVE_BUTTON = '[move]'
 const ASK_GAP = 1
+const BUTTON_GAP = 1
 const FILE_MARK = '📎'
 const QUESTION_MARK = '?'
 const OPENABLE = /^(https?|file):\/\//
@@ -85,13 +119,34 @@ const BAR_WIDTH = textWidth(`${WAITING_MARK} `)
 
 const roomOf = (width: number): number => Math.max(width - BAR_WIDTH, 1)
 
-/** The cells a row's text may take and the screen column `[ask]` starts in; no column for a row without a button. */
-const askLayout = (ask: AskTarget | null, width: number): { room: number; askColumn: number | null } => {
-  if (!ask) return { room: roomOf(width), askColumn: null }
-  const room = Math.max(roomOf(width) - (textWidth(ASK_BUTTON) + ASK_GAP), 1)
-  return { room, askColumn: BAR_WIDTH + room + ASK_GAP + 1 }
+/** The buttons of an item, `[ask]` first when the item can be asked. */
+const buttonsOf = ({ ask, buttons = [] }: Pick<BlockItem, 'ask' | 'buttons'>): BlockButton[] => [
+  ...(ask ? [{ label: ASK_BUTTON, click: { ask } }] : []),
+  ...buttons,
+]
+
+const buttonsWidth = (buttons: readonly BlockButton[]): number =>
+  buttons.reduce((sum, { label }) => sum + textWidth(label), 0) + Math.max(buttons.length - 1, 0) * BUTTON_GAP
+
+/** The cells a row's text may take and the buttons with the screen columns they start in; none for a row without one. */
+const buttonLayout = (items: readonly BlockButton[], width: number): { room: number; placed: PlacedButton[] } => {
+  if (items.length === 0) return { room: roomOf(width), placed: [] }
+  const room = Math.max(roomOf(width) - (buttonsWidth(items) + ASK_GAP), 1)
+  let column = BAR_WIDTH + room + ASK_GAP + 1
+  const placed = items.map((button) => {
+    const at = column
+    column += textWidth(button.label) + BUTTON_GAP
+    return { ...button, column: at }
+  })
+  return { room, placed }
 }
 
+/** The labels of a row's buttons as drawn after its text, one blank apart, each painted with `paintLabel`. */
+export const buttonsText = (
+  buttons: readonly BlockButton[],
+  paintLabel: (label: string) => string = (label) => label,
+): string => buttons.map(({ label }) => paintLabel(label)).join(' ')
+
 const askOf = (item: WaitingItem): AskTarget | null => {
   if (item.kind === WAITING_KIND.file) return null
   if (item.kind === WAITING_KIND.question) return item.id ? { kind: ASK_KIND.question, id: item.id } : null
@@ -126,29 +181,58 @@ const dimStarts = (lines: readonly string[], start: string, titleLength: number)
   })
 }
 
+/** What `[done]` closes: the record of a file or a question, else the row of the board; none for a record-less question. */
+const doneOf = (item: WaitingItem): DoneTarget | null => {
+  if (item.id) return { kind: DONE_KIND.record, id: item.id }
+  return item.kind === undefined ? { kind: DONE_KIND.boardRow, since: item.since, item: item.item } : null
+}
+
+const doneButtons = (item: WaitingItem): BlockButton[] => {
+  const done = doneOf(item)
+  return done ? [{ label: DONE_BUTTON, click: { done } }] : []
+}
+
+const withPrefix = (prefix: string | undefined, text: string): string => (prefix ? `${prefix}: ${text}` : text)
+
 const itemOf = (item: WaitingItem): BlockItem => ({
+  buttons: doneButtons(item),
   key: waitingKey(item),
   mark: item.kind === WAITING_KIND.file ? FILE_MARK : QUESTION_MARK,
-  text: plain(item.item),
-  title: shortTitle(plain(item.item)),
+  text: withPrefix(item.prefix, plain(item.item)),
+  title: withPrefix(item.prefix, shortTitle(plain(item.item))),
   url: item.kind === WAITING_KIND.file && item.url && OPENABLE.test(item.url) ? item.url : null,
   ask: askOf(item),
 })
 
-const rowOf = (
-  { key, mark, lead, text, title = text, url, ask }: BlockItem,
-  expandedKeys: ReadonlySet<string>,
-  width: number,
-): BlockRow => {
-  const { room, askColumn } = askLayout(ask, width)
+const rowOf = (item: BlockItem, expandedKeys: ReadonlySet<string>, width: number): BlockRow => {
+  const { key, mark, lead, text, title = text, url, ask, tone, toggle, dim } = item
+  const { room, placed } = buttonLayout(buttonsOf(item), width)
   const leadText = lead === undefined ? '' : `${lead} `
   const start = `${mark} ${leadText}`
   const cut = title !== text || textWidth(`${start}${text}`) > room
   const expanded = cut && expandedKeys.has(key)
   const [first, ...rest] = expanded ? hangingLines(start, text, room) : [fit(`${start}${title}`, room)]
-  const lines = ask ? [padVisible(first, room + ASK_GAP), ...rest] : [first, ...rest]
-  const dimFrom = dimStarts([first, ...rest], start, expanded && title !== text ? title.length : 0)
-  return { key, mark, lines, cut, expanded, url, ask, askColumn, preview: `${leadText}${title}`, dimFrom }
+  const lines = placed.length > 0 ? [padVisible(first, room + ASK_GAP), ...rest] : [first, ...rest]
+  const lineParts = [first, ...rest]
+  const dimFrom = dim
+    ? lineParts.map((_, index) => (index === 0 ? mark.length + 1 : 0))
+    : dimStarts(lineParts, start, expanded && title !== text ? title.length : 0)
+  const preview = `${leadText}${title}`
+  return {
+    key,
+    mark,
+    lines,
+    cut,
+    expanded,
+    url,
+    ask,
+    buttons: placed,
+    preview,
+    dimFrom,
+    ...(tone && { tone }),
+    ...(toggle && { toggle }),
+    ...(dim && { dim }),
+  }
 }
 
 /**
@@ -163,6 +247,13 @@ export const blockRows = (
 ): BlockRow[] =>
   (expandedKeys.has(moreKey) ? items : items.slice(0, SHOWN_BLOCK_ROWS)).map((item) => rowOf(item, expandedKeys, width))
 
+/** Every item as a row, for a block that limits its rows itself (the sources block, five entries per source). */
+export const allBlockRows = (
+  items: readonly BlockItem[],
+  expandedKeys: ReadonlySet<string>,
+  width: number,
+): BlockRow[] => items.map((item) => rowOf(item, expandedKeys, width))
+
 /** The rows the herd draws for what waits on the user. */
 export const waitingRows = (
   items: readonly WaitingItem[],
@@ -186,16 +277,30 @@ const rowAt = (
   return null
 }
 
-const onAskButton = ({ askColumn }: BlockRow, column: number | undefined): boolean =>
-  askColumn !== null && column !== undefined && column >= askColumn && column < askColumn + textWidth(ASK_BUTTON)
+const buttonAt = ({ buttons }: BlockRow, column: number | undefined): PlacedButton | undefined =>
+  column === undefined
+    ? undefined
+    : buttons.find((button) => column >= button.column && column < button.column + textWidth(button.label))
 
 const clickOn = (row: BlockRow, onFirstLine: boolean, column: number | undefined): BlockClick | null => {
-  const { key, cut, expanded, url, ask } = row
-  if (ask && onFirstLine && onAskButton(row, column)) return { ask }
+  const { key, cut, expanded, url, toggle } = row
+  const button = onFirstLine ? buttonAt(row, column) : undefined
+  if (button) return button.click
+  if (toggle) return { toggle }
   if (url) return cut && !expanded ? { toggle: key } : { open: url }
   return cut ? { toggle: key } : null
 }
 
+/**
+ * What Enter does on a row: the question is asked where the row has an `[ask]` button, else the row opens its address,
+ * expands when cut off, or does nothing. Never a `[done]` or `[run]`: those close or start something, so only a click on
+ * the button does that.
+ */
+export const mainClickOf = (row: BlockRow): BlockClick | null => {
+  const ask = row.buttons.find((button) => button.label === ASK_BUTTON)
+  return ask ? ask.click : clickOn(row, true, undefined)
+}
+
 /** Whether a plain left click hit the head line of a block, which folds and opens it. `headLine` is 0-based. */
 export const blockHeadClick = (
   headLine: number,

package/src/terminal/text.ts

@@ -47,6 +47,7 @@ export const paint = {
   red: style('31'),
   green: style('32'),
   yellow: style('33'),
+  blue: style('34'),
   magenta: style('35'),
   teal: style(tealCodeOf(process.env)),
   cyan: style('36'),
@@ -75,6 +76,13 @@ export const link = (url: string, text: string): string =>
 export const badge = (url: string, text: string, hint = '', tone: BadgeTone = BADGE_TONE.grey): string =>
   `${ESC}[${tone}m ${link(url, text)}${hint ? `${FAINT_ON} ${hint}${FAINT_OFF}` : ''} ${RESET}`
 
+/**
+ * `text` as a button in square brackets, like `[ask]`: the text linked to `url` in the normal brightness, with `hint`
+ * after it inside the brackets, faint. A square bracket means a click does something.
+ */
+export const bracket = (url: string, text: string, hint = ''): string =>
+  `[${link(url, text)}${hint ? `${FAINT_ON} ${hint}${FAINT_OFF}` : ''}]`
+
 /** `text` as a badge without a link, for what no click opens: the background of `tone`, a cell of padding either side. */
 export const box = (text: string, tone: BadgeTone = BADGE_TONE.grey): string => `${ESC}[${tone}m ${text} ${RESET}`
 

package/src/terminal/types.ts

@@ -6,6 +6,10 @@ export type AgentStatus = (typeof AGENT_STATUS)[keyof typeof AGENT_STATUS]
 export const isAgentStatus = (value: string): value is AgentStatus =>
   (Object.values(AGENT_STATUS) as string[]).includes(value)
 
+/** The states of an agent that rests: it has finished or waits for the next task, and is not working or asking. */
+export const isRestingAgent = (agent: string | null): boolean =>
+  agent === AGENT_STATUS.idle || agent === AGENT_STATUS.done
+
 /** A name to list the unnamed agent of one pane under. */
 export type AdoptedName = { pane: string; name: string }
 

package/src/vocabulary/index.ts

@@ -87,6 +87,8 @@ export const APPOINTMENT_VOCABULARY: Record<
     /** Further header names that count as the status column. */
     statusAlso: readonly string[]
     open: readonly string[]
+    /** The lower-case word an action starts with when it is the weekly board grooming, which the herd's header counts from. */
+    grooming: string
   }
 > = {
   [PLAN_LANGUAGE.de]: {
@@ -94,15 +96,23 @@ export const APPOINTMENT_VOCABULARY: Record<
     columns: { when: 'Wann', action: 'Aktion', origin: 'Herkunft', status: 'Stand' },
     statusAlso: ['Status'],
     open: ['offen'],
+    grooming: 'board-pflege',
   },
   [PLAN_LANGUAGE.en]: {
     heading: 'Appointments',
     columns: { when: 'When', action: 'Action', origin: 'Origin', status: 'Status' },
     statusAlso: [],
     open: ['open'],
+    grooming: 'board grooming',
   },
 }
 
+/** The heading of the board section of what the coordinator does next, a numbered list of at most three lines. */
+export const NEXT_VOCABULARY: Record<PlanLanguage, { heading: string }> = {
+  [PLAN_LANGUAGE.de]: { heading: 'Als Nächstes' },
+  [PLAN_LANGUAGE.en]: { heading: 'Next' },
+}
+
 /**
  * The board section of what waits on the user's answer (a sent preview, an open question, a report to accept): its
  * heading, the header names of its columns (since, item, origin, status, found by name in any order; the status

package/src/watch/plan-badges-read.ts

@@ -8,6 +8,7 @@ import {
   watchBadgesOf,
   watchHealthOf,
 } from './plan-badges'
+import { sourceStatusesOf } from './source-statuses'
 import { parseWatchState, type WatchState } from './watch-events'
 import { type CommandLineOf, isWatcherRunning, WATCHER_FILES, watcherDirectoryOf } from './watcher-lock'
 
@@ -23,7 +24,7 @@ const readState = (file: string): WatchState | null => {
 
 /**
  * What the watcher of the repository at `root` gives the herd, read from its state file without a GitHub call:
- * its badges, the tickets of `ticketSources`, and its health, so the view can say why there are none. A missing or
+ * its badges, the tickets of `ticketSources`, the status of the sources in `statusNames`, and its health, so the view can say why there are none. A missing or
  * damaged file shows no badges; the view goes on without them. Nothing is read unless both levels of the watcher
  * directory are private (`isPrivateLevels`), and only regular files, so a directory, a file or a FIFO someone else
  * planted neither feeds the view nor blocks it.
@@ -34,6 +35,7 @@ export const readWatchReading = (
   ticketSources: readonly TicketSource[],
   lookUp?: CommandLineOf,
   system: LocationSystem = systemLocation(),
+  statusNames: readonly string[] = [],
 ): WatchReading => {
   const directory = watcherDirectoryOf(root, system)
   const isPrivate = isPrivateLevels(dirname(directory), directory, system)
@@ -44,5 +46,10 @@ export const readWatchReading = (
     now,
   )
   if (!state || health.kind !== WATCH_HEALTH.live) return { badges: {}, tickets: [], health }
-  return { badges: watchBadgesOf(state, now), tickets: sourceTicketsOf(state, ticketSources, now), health }
+  return {
+    badges: watchBadgesOf(state, now),
+    tickets: sourceTicketsOf(state, ticketSources, now),
+    health,
+    ...(statusNames.length > 0 ? { sources: sourceStatusesOf(state, statusNames, now) } : {}),
+  }
 }

package/src/watch/plan-badges.ts

@@ -3,6 +3,7 @@ import { sanitisedFailedTestPlaces, sanitisedFailedTests } from './failed-tests'
 import { failedTestPlacesOf, failedTestsOf } from './failures'
 import { previewUrlOf } from './previews'
 import { PULL_REQUEST_STATE } from './pull-requests'
+import type { SourceStatus } from './source-statuses'
 import { lineText, type TicketRecord } from './sources'
 import type { WatchState } from './watch-events'
 
@@ -45,7 +46,13 @@ export type TicketBadge = { id: string; url: string | null; status: string | nul
 export type SourceTicket = TicketBadge & { lane: string | null }
 
 /** The badges the view draws, the tickets of the marked sources, and why there may be none. */
-export type WatchReading = { badges: WatchBadges; tickets: SourceTicket[]; health: WatchHealth }
+export type WatchReading = {
+  badges: WatchBadges
+  tickets: SourceTicket[]
+  health: WatchHealth
+  /** The status of the sources the herd lists; absent when none was asked for. */
+  sources?: SourceStatus[]
+}
 
 /** Three missed GitHub reads of the watcher (one a minute): an older state is not shown (D96). */
 export const STALE_AFTER_MS = 180_000
@@ -58,7 +65,8 @@ const MINUTE_MS = 60_000
 const shownFailedTestsOf = (state: WatchState, number: string, headCommit: string): string[] =>
   sanitisedFailedTests(failedTestsOf(state.failures, Number(number), headCommit))
 
-const isFresh = (savedAt: number | null, now: number): boolean => savedAt !== null && now - savedAt <= STALE_AFTER_MS
+export const isFresh = (savedAt: number | null, now: number): boolean =>
+  savedAt !== null && now - savedAt <= STALE_AFTER_MS
 
 /**
  * The health of a watcher from whether it runs and when it last saved its state. A watcher that runs but has not

package/src/watch/report-questions.ts

@@ -8,8 +8,9 @@ const CODE_FENCE = /^\s*(```|~~~)/
 const LIST_ITEM = /^(?:\d+[.)]|[-*])\s/
 const CONTINUATION_LINE = /^\s/
 const LIST_MARKER = /^(?:\d+[.)]|[-*])\s*/
-/** What a section writes when it has nothing to ask: "Keine.", "None.", "Keine offenen Fragen.", a dash. */
-const NO_QUESTIONS = /^(?:(?:keine|none|no|nein)(?:\s+(?:offenen\s+)?(?:fragen?|questions?))?\.?|n\/a|[—–])$/i
+/** What a section writes when it has nothing to ask: "Keine.", "None.", "Keine offenen Fragen.", "Keine offenen.", a dash. */
+const NO_QUESTIONS =
+  /^(?:(?:keine|none|no|nein)(?:\s+(?:(?:offen(?:en?)?|open)(?:\s+ones?)?|(?:offenen\s+)?(?:fragen?|questions?)))?\.?|n\/a|[—–])$/i
 
 /** What the questions part of a message may take: whole up to these limits, else cut question by question. */
 const QUESTION_LINES = 20
@@ -30,7 +31,7 @@ const headings = (lines: readonly string[]): { index: number; level: number; isQ
 /** True when every line of the body, ignoring blank lines, a list marker and bold, says there is nothing to ask. */
 const asksNothing = (body: readonly string[]): boolean =>
   body
-    .map((line) => line.trim().replace(LIST_MARKER, '').replaceAll('**', '').trim())
+    .map((line) => line.replaceAll('**', '').trim().replace(LIST_MARKER, '').trim())
     .filter((text) => text !== '')
     .every((text) => NO_QUESTIONS.test(text))
 

package/src/watch/source-entries.ts

@@ -0,0 +1,55 @@
+import {
+  lineText,
+  reportsItem,
+  type SeenEntry,
+  type SourceEntry,
+  type SourceItem,
+  type SourceRecord,
+  type SourceRun,
+  type SourceSettings,
+  seenMapOf,
+  storedValue,
+} from './sources'
+
+/** The most entries a source keeps for the herd. */
+export const ENTRY_LIMIT = 20
+
+const shownAt = ({ changedAt, seenAt }: SourceEntry): number => changedAt ?? seenAt
+
+const entryOf = (
+  item: SourceItem,
+  known: SourceEntry | undefined,
+  seen: ReadonlyMap<string, SeenEntry> | null,
+  settings: SourceSettings,
+  now: number,
+): SourceEntry => ({
+  id: item.id,
+  title: storedValue(lineText(item.title)),
+  url: item.url,
+  count: item.count,
+  seenAt: known?.seenAt ?? now,
+  changedAt: seen && reportsItem(seen, item, settings) ? now : (known?.changedAt ?? null),
+})
+
+/**
+ * The entries a source that is no ticket keeps after `run`: those of a successful run, at most `ENTRY_LIMIT`, newest
+ * change first, each with the time the watcher first saw it and the time it last reported a change of it (none for the
+ * baseline run). A failed run keeps what the source had; a ticket source keeps none (its tickets are the list).
+ */
+export const entriesAfter = (
+  previous: SourceRecord | undefined,
+  run: SourceRun | undefined,
+  settings: SourceSettings | undefined,
+  now: number,
+): SourceEntry[] | undefined => {
+  if (!settings || settings.ticket) return undefined
+  if (!run?.result.ok) return previous?.entries
+  const seen = seenMapOf(previous)
+  const known = new Map((previous?.entries ?? []).map((entry) => [entry.id, entry]))
+  return run.result.items
+    .map((item) => entryOf(item, known.get(item.id), seen, settings, now))
+    .map((entry, index) => ({ entry, index }))
+    .sort((a, b) => shownAt(b.entry) - shownAt(a.entry) || a.index - b.index)
+    .map(({ entry }) => entry)
+    .slice(0, ENTRY_LIMIT)
+}

package/src/watch/source-fields.ts

@@ -7,6 +7,7 @@ export const SOURCE_FIELD = {
   body: 'body',
   author: 'author',
   status: 'status',
+  count: 'count',
 } as const
 
 /** The fields a reader sees of an entry: a change of one of them is a change of the entry (`contentFingerprint`). */

package/src/watch/source-statuses.ts

@@ -0,0 +1,60 @@
+import { isFresh, NEW_FOR_MS } from './plan-badges'
+import { previewUrlOf } from './previews'
+import { lineText, type SourceEntry, type SourceRecord } from './sources'
+import type { WatchState } from './watch-events'
+
+/** The newest entry a source reported, as the herd draws it; `isNew` while it is younger than `NEW_FOR_MS`. */
+export type LatestStatus = { title: string; url: string | null; isNew: boolean }
+
+/** An entry as the herd lists it under its source: `at` is when it last changed, else when the watcher first saw it; `isNew` only for a reported change younger than `NEW_FOR_MS`. */
+export type EntryStatus = {
+  id: string
+  title: string
+  url: string | null
+  count: string | null
+  at: number
+  isNew: boolean
+}
+
+/** What the herd shows of a source: when it ran last, since when it fails, its newest report and its entries, newest change first. */
+export type SourceStatus = {
+  name: string
+  ranAt: number | null
+  failingSince: number | null
+  latest: LatestStatus | null
+  entries: EntryStatus[]
+}
+
+const entryStatusOf = (entry: SourceEntry, now: number): EntryStatus => ({
+  id: entry.id,
+  title: lineText(entry.title),
+  url: entry.url === null ? null : previewUrlOf(entry.url, undefined),
+  count: entry.count,
+  at: entry.changedAt ?? entry.seenAt,
+  isNew: entry.changedAt !== null && now - entry.changedAt < NEW_FOR_MS,
+})
+
+const latestOf = (latest: SourceRecord['latest'], now: number): LatestStatus | null =>
+  latest
+    ? {
+        title: lineText(latest.title),
+        url: latest.url === null ? null : previewUrlOf(latest.url, undefined),
+        isNew: now - latest.at < NEW_FOR_MS,
+      }
+    : null
+
+const statusOf = (name: string, record: SourceRecord | undefined, now: number): SourceStatus => ({
+  name,
+  ranAt: record?.ranAt ?? null,
+  failingSince: record?.failingSince ?? null,
+  latest: latestOf(record?.latest, now),
+  entries: (record?.entries ?? []).map((entry) => entryStatusOf(entry, now)),
+})
+
+/**
+ * The status of each source in `names`, in their order, from the watcher's saved state alone. A name the watcher has
+ * not run yet shows without a run; a title is drawn as one line and the URL is checked again, as for the tickets, and a
+ * state older than `STALE_AFTER_MS` shows none.
+ */
+export const sourceStatusesOf = (state: WatchState, names: readonly string[], now: number): SourceStatus[] =>
+  isFresh(state.savedAt, now) ? names.map((name) => statusOf(name, state.sources[name], now)) : []

package/src/watch/source-tickets.ts

@@ -1,4 +1,7 @@
+import { entriesAfter } from './source-entries'
 import {
+  type LatestReport,
+  lineText,
   recordSources,
   reportsItem,
   SEEN_LIMIT,
@@ -9,6 +12,7 @@ import {
   type SourceSettings,
   type SourceState,
   seenMapOf,
+  storedValue,
   type TicketRecord,
 } from './sources'
 
@@ -39,6 +43,19 @@ const ticketsAfter = (
   )
 }
 
+/** The newest entry this run reported (the last of them), else what was recorded; failures and baselines record nothing. */
+const latestAfter = (
+  previous: SourceRecord | undefined,
+  run: SourceRun | undefined,
+  settings: SourceSettings | undefined,
+  now: number,
+): LatestReport | undefined => {
+  const seen = seenMapOf(previous)
+  if (!seen || !settings || !run?.result.ok) return previous?.latest
+  const reported = run.result.items.filter((item) => reportsItem(seen, item, settings)).at(-1)
+  return reported ? { title: storedValue(lineText(reported.title)), url: reported.url, at: now } : previous?.latest
+}
+
 const withoutTickets = ({ tickets: _tickets, ...record }: SourceRecord): SourceRecord => record
 
 /** The tickets a source keeps: those of a successful run, else the ones it had; none for a source not marked. */
@@ -71,7 +88,10 @@ const recordTickets = (
       const source = settings.find((candidate) => candidate.name === name)
       const run = runs.find((candidate) => candidate.name === name)
       const tickets = ticketsOf(previous[name], run, source, now)
-      return [name, tickets ? { ...withoutTickets(record), tickets } : withoutTickets(record)]
+      const latest = latestAfter(previous[name], run, source, now)
+      const entries = entriesAfter(previous[name], run, source, now)
+      const base = { ...withoutTickets(record), ...(latest ? { latest } : {}), ...(entries ? { entries } : {}) }
+      return [name, tickets ? { ...base, tickets } : base]
     }),
   )
 

package/src/watch/sources.ts

@@ -67,6 +67,8 @@ export type SourceItem = {
   author: string | null
   /** `map.status` as the state keeps it (`storedValue`), null when not mapped or empty. */
   status: string | null
+  /** `map.count` as one line (how often an error happened); null when not mapped or empty. */
+  count: string | null
   fingerprint: string
   /** The `reportOn` fields as the state keeps them (`storedValue`); empty without `reportOn`. */
   values: Record<string, string>
@@ -86,6 +88,22 @@ export type SeenEntry = [string, string] | [string, string, Record<string, strin
  */
 export type TicketRecord = { url: string | null; status: string | null; changedAt: number | null }
 
+/** The newest entry a source reported: its title as one line, its checked URL or null, and the epoch milliseconds of the run that reported it. */
+export type LatestReport = { title: string; url: string | null; at: number }
+
+/**
+ * An entry of a source as the herd lists it: its title as one line, its checked URL, its count, when the watcher first
+ * saw it (`seenAt`) and when it last reported a change of it (`changedAt`, null while only the baseline knows it).
+ */
+export type SourceEntry = {
+  id: string
+  title: string
+  url: string | null
+  count: string | null
+  seenAt: number
+  changedAt: number | null
+}
+
 /**
  * What the watcher keeps per source: `seen` holds a `SeenEntry` per id, the entries seen most recently last, or null
  * before the first successful run (which is a baseline); `failingSince` is the epoch milliseconds of the first failed
@@ -98,6 +116,10 @@ export type SourceRecord = {
   ranAt?: number
   /** Of a ticket source only: the entries of its last successful run by id. */
   tickets?: Record<string, TicketRecord>
+  /** The newest entry the source reported, kept for the herd's row of the source; absent until one was reported. */
+  latest?: LatestReport
+  /** Of a source that is no ticket: the entries of its last successful run for the herd's expanded row, newest change first. */
+  entries?: SourceEntry[]
 }
 
 export type SourceState = Record<string, SourceRecord>
@@ -145,7 +167,7 @@ const scalarText = (value: unknown): string | null => {
 export const textAt = (entry: unknown, path: SourcePath | undefined): string | null =>
   path === undefined ? null : scalarText(selectPath(entry, path))
 
-type MappedFields = Omit<SourceItem, 'fingerprint' | 'values' | 'status'>
+type MappedFields = Omit<SourceItem, 'fingerprint' | 'values' | 'status' | 'count'>
 
 const hashOf = (text: string, length: number): string =>
   createHash('sha256').update(text).digest('hex').slice(0, length)
@@ -191,6 +213,9 @@ const valuesOf = (
 const statusOf = (entry: unknown, map: SourceMap): string | null =>
   storedValue(lineText(textAt(entry, map.status) ?? '')) || null
 
+const countOf = (entry: unknown, map: SourceMap): string | null =>
+  storedValue(lineText(textAt(entry, map.count) ?? '')) || null
+
 /** One entry after `map`, or null when its id, or a mapped updatedAt, is missing or no text; unmapped it is `''`. */
 const sourceItemOf = (entry: unknown, settings: Pick<SourceSettings, 'map' | 'reportOn'>): SourceItem | null => {
   const { map } = settings
@@ -209,6 +234,7 @@ const sourceItemOf = (entry: unknown, settings: Pick<SourceSettings, 'map' | 're
   return {
     ...fields,
     status: statusOf(entry, map),
+    count: countOf(entry, map),
     fingerprint: contentFingerprint(fields, map),
     values: valuesOf(entry, fields, settings),
   }
@@ -383,8 +409,22 @@ const isTicketRecord = (value: unknown): boolean =>
   isTextOrNull(value.status) &&
   (value.changedAt === null || typeof value.changedAt === 'number')
 
+const isLatestReport = (value: unknown): boolean =>
+  isRecord(value) && typeof value.title === 'string' && isTextOrNull(value.url) && typeof value.at === 'number'
+
+const isSourceEntry = (value: unknown): boolean =>
+  isRecord(value) &&
+  typeof value.id === 'string' &&
+  typeof value.title === 'string' &&
+  isTextOrNull(value.url) &&
+  isTextOrNull(value.count) &&
+  typeof value.seenAt === 'number' &&
+  (value.changedAt === null || typeof value.changedAt === 'number')
+
 const isSourceRecord = (value: unknown): boolean =>
   isRecord(value) &&
+  (value.entries === undefined || (Array.isArray(value.entries) && value.entries.every(isSourceEntry))) &&
+  (value.latest === undefined || isLatestReport(value.latest)) &&
   (value.seen === null || (Array.isArray(value.seen) && value.seen.every(isSeenEntry))) &&
   (value.failingSince === null || typeof value.failingSince === 'number') &&
   (value.ranAt === undefined || typeof value.ranAt === 'number') &&