jackherd 1.10.0 → 1.11.1

package/src/plans/live.ts

@@ -4,6 +4,8 @@ import { pathToFileURL } from 'node:url'
 import { terminalSafe } from '../plan-format/terminal-text'
 import { runHerdr } from '../terminal/herdr'
 import { openInBrowser } from '../terminal/open'
+import { stripAnsi } from '../terminal/text'
+import { closeWaiting } from '../waiting/command'
 import { appointmentKeys } from './appointment-rows'
 import { askCoordinator } from './ask-coordinator'
 import type { LaneMemory } from './current-phase'
@@ -21,16 +23,22 @@ import {
 import { fetchHeadPath } from './git'
 import { fetchPullRequests, noPullRequests, type PullRequestState } from './github'
 import { recallLanes, rememberLanes } from './herd-memory'
-import type { Screen } from './layout'
+import { type Screen, settledSelection } from './layout'
+import { nextKeys } from './next-rows'
 import { type KnownPage, pageAfterWrite, pageKey, pageNeedsWriting, planAnchorOn, withPlanChips } from './plan-chips'
 import { planPullRequests } from './plan-heads'
 import { herdLabel } from './plan-panes'
 import { pullRequestUrl } from './pull-requests'
 import { newReadCache, type ReadCache } from './read-cache'
 import { TAKEN_OVER_CODE, TAKEOVER_SIGNAL } from './restart-decision'
+import { closeRow } from './row-actions'
+import { blockRowByKey, bracketAt, hoveredKeyAt, lineIndexAt, withHovered } from './row-focus'
 import {
   inputOutcome,
+  isActivateKey,
+  isMotion,
   isSprintPageKey,
+  type MouseEvent,
   overviewSelection,
   parseMouse,
   settledBlockFolds,
@@ -39,7 +47,6 @@ import {
   syncLaneFolds,
   TOP_BLOCK,
   type TopBlockId,
-  targetKeys,
   toggledBlockFold,
   toggledExpansion,
   type View,
@@ -48,6 +55,7 @@ import {
 import { BASE_REMOTE, baseRefOf, boardRepoPathOf, CLOCK_LOCALE } from './settings'
 import { singleFlight } from './single-flight'
 import { loadSnapshot, type Snapshot, type Source } from './snapshot'
+import { sourceKeys } from './source-rows'
 import { exportSprintPage, writeSprintPageInSteps } from './sprint-export'
 import { boardTexts } from './texts'
 import {
@@ -61,7 +69,7 @@ import {
   TERMINAL_OFF,
   TERMINAL_ON,
 } from './view'
-import { type BlockClick, type BlockHit, blockClick, blockHeadClick, waitingKeys } from './waiting-click'
+import { type BlockClick, type BlockHit, blockClick, blockHeadClick, mainClickOf, waitingKeys } from './waiting-click'
 
 /** The state of the running view; only the functions below `runLive` change it. */
 type Live = {
@@ -240,7 +248,9 @@ const readOnce = async (live: Live, onChange: () => void) => {
     )
     const settled = settledBlockFolds(folded, {
       waiting: waitingKeys(next.waiting ?? []),
+      next: nextKeys(next.next?.rows ?? []),
       appointments: appointmentKeys(next.appointments?.rows ?? []),
+      sources: sourceKeys(next.sourceBlock?.sources ?? []),
     })
     live.view = { ...live.view, selection: settled }
     live.snapshot = next
@@ -308,6 +318,15 @@ const applyBlockClick = (live: Live, outcome: BlockClick): void => {
     })
     return
   }
+  if ('done' in outcome) {
+    live.notice = closeRow(outcome.done, {
+      sprintFile: live.source.sprintFile,
+      language: live.source.settings.planLanguage,
+      now: new Date(),
+      closeRecords: (ids) => closeWaiting(live.source.root, ids, Date.now()),
+    })
+    return
+  }
   const reason = openInBrowser(outcome.open)
   if (reason) live.notice = boardTextsOf(live).notOpened(terminalSafe(reason))
 }
@@ -333,23 +352,72 @@ const clickBlock = (live: Live, block: TopBlockId, hit: BlockHit | null, input:
   return true
 }
 
+/** The mouse moved: the row under it is drawn like the selected one, and the screen is redrawn only when that row changes. */
+const hover = (live: Live, screen: Screen, mouse: MouseEvent): void => {
+  const frame = { headerRows: screen.header.length, bodyRows: bodyRows(screen), top: live.view.top }
+  const key = hoveredKeyAt(screen.focusHits, mouse, frame)
+  const line = lineIndexAt(mouse, frame)
+  const text = line === null ? '' : (screen.header[line] ?? screen.body.lines[line - frame.headerRows] ?? '')
+  const selection = withHovered(
+    live.view.selection,
+    key,
+    key === null ? null : bracketAt(stripAnsi(text), mouse.column - 1),
+  )
+  if (selection === live.view.selection) return
+  live.view = { ...live.view, selection }
+  redraw(live)
+}
+
+/**
+ * Enter or space on the selected row of a block on top does its main action (`mainClickOf`: ask, open, expand); true
+ * when the input was for such a row, whether or not it had anything to do.
+ */
+const activateBlockRow = (live: Live, screen: Screen, input: string): boolean => {
+  if (!isActivateKey(input)) return false
+  const key = live.view.selection.selected
+  const row = key === null ? null : blockRowByKey(blocksOf(screen), key)
+  if (!row) return false
+  const click = mainClickOf(row)
+  if (click) applyBlockClick(live, click)
+  return true
+}
+
+const blocksOf = ({ waitingBlock, nextBlock, appointmentBlock, sourceBlock }: Screen): (BlockHit | null)[] => [
+  waitingBlock,
+  nextBlock,
+  appointmentBlock,
+  sourceBlock,
+]
+
 const handleInput = (live: Live, input: string) => {
   const { snapshot, screen } = live
   if (!snapshot || !screen) return
+  const mouse = parseMouse(input)
+  if (mouse && isMotion(mouse)) {
+    hover(live, screen, mouse)
+    return
+  }
   live.notice = null
+  live.view = { ...live.view, selection: settledSelection(live.view.selection, screen) }
+  if (activateBlockRow(live, screen, input)) {
+    redraw(live)
+    return
+  }
   if (isSprintPageKey(input)) {
     void writeSprintPage(live, snapshot)
     return
   }
   if (
     clickBlock(live, TOP_BLOCK.waiting, screen.waitingBlock, input) ||
-    clickBlock(live, TOP_BLOCK.appointments, screen.appointmentBlock, input)
+    clickBlock(live, TOP_BLOCK.next, screen.nextBlock, input) ||
+    clickBlock(live, TOP_BLOCK.appointments, screen.appointmentBlock, input) ||
+    clickBlock(live, TOP_BLOCK.sources, screen.sourceBlock, input)
   ) {
     redraw(live)
     return
   }
   const context = {
-    keys: targetKeys(screen.body.targets),
+    keys: screen.rowKeys,
     targets: screen.body.targets,
     headerRows: screen.header.length,
     bodyRows: bodyRows(screen),

package/src/plans/next-rows.ts

@@ -0,0 +1,44 @@
+import { sectionLines } from '../plan-format/markdown'
+import { NEXT_VOCABULARY, type PlanLanguage } from '../vocabulary'
+import { shortTitle } from './task-name'
+import type { BlockItem } from './waiting-click'
+
+/** A line of the board's next section as the herd shows it. */
+export type NextRow = { text: string }
+
+/** The next block: the section's lines without the ones the for-you block already shows. */
+export type NextBlock = { rows: NextRow[] }
+
+const MAX_NEXT_ROWS = 3
+
+const LIST_LINE = /^(?:\d+[.)]|[-*])\s+(.+)$/
+
+const sameText = (left: string, right: string): boolean => left.trim().toLowerCase() === right.trim().toLowerCase()
+
+/**
+ * The next section of the board, up to three list lines in the order written; the parser cuts after three, as the board
+ * says. A line equal to one of `shown` (the texts of the for-you block) is left out: it stands above already.
+ */
+export const nextBlock = (board: string, language: PlanLanguage, shown: readonly string[]): NextBlock => ({
+  rows: sectionLines(board, NEXT_VOCABULARY[language].heading)
+    .flatMap((line) => LIST_LINE.exec(line.trim())?.[1] ?? [])
+    .slice(0, MAX_NEXT_ROWS)
+    .filter((text) => !shown.some((known) => sameText(known, text)))
+    .map((text) => ({ text })),
+})
+
+const nextKey = ({ text }: NextRow): string => `next>${text}`
+
+/** The rows as the block draws them, numbered; a click on one only expands it. */
+export const nextItems = (rows: readonly NextRow[]): BlockItem[] =>
+  rows.map((row, index) => ({
+    key: nextKey(row),
+    mark: String(index + 1),
+    text: row.text,
+    title: shortTitle(row.text),
+    url: null,
+    ask: null,
+  }))
+
+/** The keys of all rows: what the fold of the block remembers. */
+export const nextKeys = (rows: readonly NextRow[]): string[] => rows.map(nextKey)

package/src/plans/planned.ts

@@ -19,8 +19,15 @@ export type PlannedPlan = {
   phaseIds: string[]
   done: number
   total: number
+  /** Set when the plan file was last changed `STALE_PLAN_DAYS` or more days ago; absent otherwise or when git does not know. */
+  stale?: true
 }
 
+/** Days without a change to its plan file from which a planned phase reads `stale?`. */
+export const STALE_PLAN_DAYS = 14
+
+const DAY_MS = 86_400_000
+
 /** A lane of the sprint and what its agent reports, null when it has none. */
 export type PlannedLane = { lane: SprintLane; agent: string | null }
 
@@ -76,9 +83,24 @@ export const plannedPlans = (input: PlannedInput): PlannedPlan[] => {
   })
 }
 
+/** The plans with `stale` set on those whose file `touchedAt` says was last changed `STALE_PLAN_DAYS` or more days before `now`. */
+export const markStale = (
+  plans: readonly PlannedPlan[],
+  touchedAt: (path: string) => number | null,
+  now: number,
+): PlannedPlan[] =>
+  plans.map((plan) => {
+    const touched = touchedAt(plan.path)
+    return touched !== null && now - touched >= STALE_PLAN_DAYS * DAY_MS ? { ...plan, stale: true } : plan
+  })
+
 /** `P3 P4 P5` */
 export const phaseList = (plan: Pick<PlannedPlan, 'phaseIds'>): string => phaseLabels(plan.phaseIds, ' ')
 
+/** `P3`: the phase of the plan that comes next, the first open one in the order of the plan. */
+export const plannedNextLabel = (plan: Pick<PlannedPlan, 'phaseIds' | 'stale'>): string =>
+  `${phaseLabels(plan.phaseIds.slice(0, 1), ' ')}${plan.stale ? ' stale?' : ''}`
+
 /** How many phases the plans list together. */
 export const plannedPhaseCount = (planned: readonly Pick<PlannedPlan, 'phaseIds'>[]): number =>
   planned.reduce((count, plan) => count + plan.phaseIds.length, 0)

package/src/plans/row-actions.ts

@@ -0,0 +1,52 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+import type { PlanLanguage } from '../vocabulary'
+import { boardRowKey } from './ask-target'
+import { closeAppointmentRow, closeWaitingRow } from './board-close'
+import { errorText } from './error-text'
+import { isQuestionId } from './question-records'
+import { DONE_KIND, type DoneTarget } from './row-targets'
+import { TEXTS } from './texts'
+
+/** What `closeRow` needs from the outside: the board file, its language, the clock, and the closing of log records. */
+export type CloseDependencies = {
+  sprintFile: string
+  language: PlanLanguage
+  now: Date
+  /** Closes the records of the files and questions log by id; how many it closed. */
+  closeRecords: (ids: readonly string[]) => number
+}
+
+const closeRecord = (id: string, { closeRecords }: CloseDependencies): string => {
+  if (!isQuestionId(id)) return TEXTS.notClosed('not a record id')
+  return closeRecords([id]) > 0 ? TEXTS.closed(`record ${id}`) : TEXTS.notClosed('record not found or closed already')
+}
+
+const closedBoard = (target: DoneTarget, board: string, { language, now }: CloseDependencies): string | null => {
+  if (target.kind === DONE_KIND.boardRow) return closeWaitingRow(board, language, target, now)
+  return target.kind === DONE_KIND.appointment ? closeAppointmentRow(board, language, target, now) : null
+}
+
+const subjectOfRow = (target: DoneTarget): string => {
+  if (target.kind === DONE_KIND.boardRow) return `board row ${boardRowKey(target.since, target.item)}`
+  return target.kind === DONE_KIND.appointment ? `appointment ${boardRowKey(target.when, target.action)}` : ''
+}
+
+const closeBoardRow = (target: DoneTarget, dependencies: CloseDependencies): string => {
+  try {
+    const board = readFileSync(dependencies.sprintFile, 'utf8')
+    const closed = closedBoard(target, board, dependencies)
+    if (closed === null) return TEXTS.notClosed('row not found in the board')
+    writeFileSync(dependencies.sprintFile, closed)
+    return TEXTS.closed(subjectOfRow(target))
+  } catch (error) {
+    return TEXTS.notClosed(errorText(error))
+  }
+}
+
+/**
+ * Closes what a `[done]` button names: a log record by its id, or a row of the board's file by writing the stamp into its
+ * status cell. Returns the footer line. The board is read again just before it is written, so a row the coordinator
+ * changed since the herd drew it is found by its text or not at all.
+ */
+export const closeRow = (target: DoneTarget, dependencies: CloseDependencies): string =>
+  target.kind === DONE_KIND.record ? closeRecord(target.id, dependencies) : closeBoardRow(target, dependencies)

package/src/plans/row-focus.ts

@@ -0,0 +1,148 @@
+import { ESC, RESET, stripAnsi, visibleLength } from '../terminal/text'
+import { textWidth } from '../terminal/width'
+import { isChipKey } from './link-chips'
+import type { ClickTarget, MouseEvent, Selection } from './selection'
+import type { BlockHit, BlockRow } from './waiting-click'
+
+/** A clickable row on screen: its key, the screen line (0-based, header lines first) it starts on and how many lines it takes. */
+export type FocusHit = { key: string; line: number; lines: number }
+
+export const FOCUS_MARK = '❯'
+export const FOCUS_ON = `${ESC}[48;5;238m`
+
+const BACKGROUND_LOST = new RegExp(`${ESC}\\[(?:0|49)?m`, 'g')
+const LEADING_STYLES = new RegExp(`^((?:${ESC}\\[[0-9;]*m)*)(.)`, 'u')
+/** The cells a row's lead may give up for the mark: a blank, the bar of a block, the closed chevron; an open chevron or a tree branch says more. */
+const MARKABLE_LEADS = new Set([' ', '▌', '▸'])
+
+const markedLead = (line: string): string =>
+  line.replace(LEADING_STYLES, (whole, styles: string, lead: string) =>
+    MARKABLE_LEADS.has(lead) ? `${styles}${FOCUS_MARK}` : whole,
+  )
+
+/**
+ * A row under the mouse or the selection: a light background across `width` cells, and, on the first line of the row
+ * (`marked`), the `❯` in place of the bar, blank or closed chevron that leads it. The background is laid again after
+ * every reset inside the line, so styled text and buttons keep it.
+ */
+export const focusLine = (line: string, width: number, marked: boolean): string => {
+  const shown = marked ? markedLead(line) : line
+  const padded = `${shown}${' '.repeat(Math.max(width - visibleLength(shown), 0))}`
+  return `${FOCUS_ON}${padded.replace(BACKGROUND_LOST, (reset) => `${reset}${FOCUS_ON}`)}${RESET}`
+}
+
+/** The row on screen line `line`, null where none is. */
+export const focusHitAt = (hits: readonly FocusHit[], line: number): FocusHit | null =>
+  hits.find((hit) => line >= hit.line && line < hit.line + hit.lines) ?? null
+
+/** The screen a motion report is looked up on: header lines, the body's rows and how far it is scrolled. */
+export type HoverFrame = { headerRows: number; bodyRows: number; top: number }
+
+/** The screen line (0-based, header first, the body unscrolled) under a motion report; null in the footer. */
+export const lineIndexAt = ({ row }: MouseEvent, { headerRows, bodyRows, top }: HoverFrame): number | null => {
+  const line = row - 1
+  if (line < headerRows) return line
+  const bodyLine = line - headerRows
+  return bodyLine < bodyRows ? headerRows + top + bodyLine : null
+}
+
+/** The key of the row under the mouse, null over none. */
+export const hoveredKeyAt = (hits: readonly FocusHit[], mouse: MouseEvent, frame: HoverFrame): string | null => {
+  const line = lineIndexAt(mouse, frame)
+  return line === null ? null : (focusHitAt(hits, line)?.key ?? null)
+}
+
+const BRACKET_BUTTON = /\[[^[\]]+\]/g
+
+/** The columns `[from, to)` of the square-bracket buttons in the visible text of a line. */
+export const bracketSpans = (visible: string): { from: number; to: number }[] =>
+  [...visible.matchAll(BRACKET_BUTTON)].map((match) => {
+    const from = textWidth(visible.slice(0, match.index))
+    return { from, to: from + textWidth(match[0]) }
+  })
+
+/** The column a square-bracket button under `column` starts in, null where the mouse is over none. */
+export const bracketAt = (visible: string, column: number): number | null =>
+  bracketSpans(visible).find((span) => column >= span.from && column < span.to)?.from ?? null
+
+const STYLE_OR_LINK = new RegExp(`(${ESC}\\[[0-9;]*m|${ESC}\\]8;[^;${ESC}\\x07]*;[^${ESC}\\x07]*(?:${ESC}\\\\|\\x07))`)
+const BOLD_ON = `${ESC}[1m`
+const BOLD_OFF = `${ESC}[22m`
+
+/** The line with the cells `[from, to)` bold, counted by what shows; styles and links in the line stay where they are. */
+export const boldCells = (line: string, from: number, to: number): string => {
+  let column = 0
+  return line
+    .split(STYLE_OR_LINK)
+    .map((token, index) => {
+      if (index % 2 === 1) return token
+      return [...token]
+        .map((character) => {
+          const start = column
+          column += textWidth(character)
+          const opens = start === from ? BOLD_ON : ''
+          const closes = column >= to && start < to ? BOLD_OFF : ''
+          return `${opens}${character}${closes}`
+        })
+        .join('')
+    })
+    .join('')
+}
+
+/** The line with the square-bracket button that starts in column `from` bold; the line itself where none does. */
+export const boldBracketAt = (line: string, from: number): string => {
+  const span = bracketSpans(stripAnsi(line)).find((each) => each.from === from)
+  return span ? boldCells(line, span.from, span.to) : line
+}
+
+/** The key of the hit of a line that holds links but is no row of its own: it is marked by the mouse only. */
+export const LINKS_KEY_PREFIX = 'links@'
+
+/** The selection with the row under the mouse and the button in it set; the selection itself while both are the same. */
+export const withHovered = (selection: Selection, key: string | null, from: number | null = null): Selection =>
+  (selection.hovered ?? null) === key && (selection.hoveredFrom ?? null) === from
+    ? selection
+    : { ...selection, hovered: key, hoveredFrom: from }
+
+/** Whether a row is the selected one or the one under the mouse. */
+export const isFocused = ({ selected, hovered }: Selection, key: string): boolean => key === selected || key === hovered
+
+/** Whether the buttons of a row are all bold: it is the row the arrows selected, and the mouse is not on it. */
+export const buttonsAllBold = ({ selected, hovered }: Selection, key: string): boolean =>
+  key === selected && key !== hovered
+
+/** The row of a drawn block that has `key`, null for a key of the body. */
+export const blockRowByKey = (blocks: readonly (BlockHit | null)[], key: string): BlockRow | null =>
+  blocks.flatMap((block) => block?.rows ?? []).find((row) => row.key === key) ?? null
+
+/** The rows of a block on top of the herd, from the screen line of its first row; none while the block is not drawn or folded. */
+export const focusHitsOfBlock = (block: BlockHit | null): FocusHit[] => {
+  let line = block?.firstLine ?? 0
+  return (block?.rows ?? []).map((row) => {
+    const hit = { key: row.key, line, lines: row.lines.length }
+    line += row.lines.length
+    return hit
+  })
+}
+
+/**
+ * The rows of a body from the lines its whole-line targets span, `offset` screen lines below the top; a chip is part of
+ * its row. A line with chips and no row of its own (the links under a lane) is a hit under a key made of its line.
+ */
+export const focusHitsOfTargets = (targets: readonly ClickTarget[], offset: number): FocusHit[] => {
+  const hits = new Map<string, FocusHit>()
+  for (const { key, line, wholeLine } of targets) {
+    if (!wholeLine || isChipKey(key)) continue
+    const known = hits.get(key)
+    hits.set(
+      key,
+      known ? { ...known, lines: line + 1 - (known.line - offset) } : { key, line: offset + line, lines: 1 },
+    )
+  }
+  const rowLines = new Set(targets.filter(({ wholeLine }) => wholeLine).map(({ line }) => line))
+  const linkLines = [...new Set(targets.filter(({ key }) => isChipKey(key)).map(({ line }) => line))]
+  const links = linkLines
+    .filter((line) => !rowLines.has(line))
+    .map((line) => ({ key: `${LINKS_KEY_PREFIX}${offset + line}`, line: offset + line, lines: 1 }))
+  return [...hits.values(), ...links]
+}

package/src/plans/row-targets.ts

@@ -0,0 +1,7 @@
+/** What a `[done]` button closes: a record of the files and questions log, a row of the waiting section, an appointment row. */
+export const DONE_KIND = { record: 'record', boardRow: 'boardRow', appointment: 'appointment' } as const
+
+export type DoneTarget =
+  | { kind: typeof DONE_KIND.record; id: string }
+  | { kind: typeof DONE_KIND.boardRow; since: string; item: string }
+  | { kind: typeof DONE_KIND.appointment; when: string; action: string }

package/src/plans/selection.ts

@@ -10,7 +10,7 @@ import { TEXTS } from './texts'
 export type LaneFold = { open: boolean }
 
 /** The blocks on top of the herd, by the name their fold is remembered under. */
-export const TOP_BLOCK = { waiting: 'waiting', appointments: 'appointments' } as const
+export const TOP_BLOCK = { waiting: 'waiting', next: 'next', appointments: 'appointments', sources: 'sources' } as const
 export type TopBlockId = (typeof TOP_BLOCK)[keyof typeof TOP_BLOCK]
 
 /**
@@ -20,6 +20,10 @@ export type TopBlockId = (typeof TOP_BLOCK)[keyof typeof TOP_BLOCK]
  */
 export type Selection = {
   selected: string | null
+  /** The row under the mouse, null or absent while it is over none; drawn like the selected one. */
+  hovered?: string | null
+  /** The column the square-bracket button under the mouse starts in; null or absent while the mouse is over none. */
+  hoveredFrom?: number | null
   expanded: ReadonlySet<string>
   showDone: boolean
   showLegend: boolean
@@ -313,6 +317,9 @@ export const applyKey = (selection: Selection, input: string, keys: readonly str
   return selection
 }
 
+/** Whether an input is enter or space, which acts on the selected row. */
+export const isActivateKey = (input: string): boolean => isInput(INPUT.toggle, input)
+
 /** The key that writes the whole sprint as an HTML page and opens it. */
 export const isSprintPageKey = (input: string): boolean => isInput(INPUT.sprintPage, input)
 
@@ -322,6 +329,12 @@ export const parseMouse = (key: string): MouseEvent | null => {
   return { button: Number(match[1]), column: Number(match[2]), row: Number(match[3]), pressed: match[4] === 'M' }
 }
 
+const MOTION_BIT = 32
+
+/** Whether a report is the mouse moving (with or without a button held), not a click, a release or the wheel. */
+export const isMotion = ({ button, pressed }: MouseEvent): boolean =>
+  pressed && button >= MOTION_BIT && button < MOUSE_BUTTON.wheelUp
+
 export const targetAt = (targets: readonly ClickTarget[], line: number, column: number): string | null =>
   targets.find((target) => target.line === line && column >= target.from && column < target.to)?.key ?? null
 

package/src/plans/settings.ts

@@ -3,6 +3,7 @@ import { join, relative } from 'node:path'
 import { type JackherdConfig, parseJackherdConfig } from '../config'
 import { PROJECT_CONFIG_PATH } from '../config/location'
 import { readConfig } from '../config/read-config'
+import type { ToneName } from '../config/tones'
 import type { TicketSource } from '../watch/plan-badges'
 
 export const CONFIG_PATH = PROJECT_CONFIG_PATH
@@ -17,6 +18,12 @@ export type PlansSettings = Pick<
   context: JackherdConfig['plans']['context']
   /** The `watch.sources` marked `ticket`, whose entries the view shows as badges. */
   ticketSources: TicketSource[]
+  /** The other `watch.sources` by name, with the tone each names for a new report; the herd lists them in a block of their own. */
+  herdSources: { name: string; tone: ToneName | null }[]
+  /** By source name: what the herd puts before a row of "Waiting for you" that came from the source, its `label` or else its name. */
+  sourceLabels: Record<string, string>
+  /** The tone of each role in the herd. */
+  tones: JackherdConfig['plans']['tones']
 }
 
 /** The locale of the herd's clock: the herd is English, with a 24-hour clock. */
@@ -38,6 +45,9 @@ export const plansSettingsOf = (config: JackherdConfig): PlansSettings => ({
   ticketSources: config.watch.sources.flatMap(({ name, lane, ticket }) =>
     ticket ? [{ name, lane: lane ?? null }] : [],
   ),
+  herdSources: config.watch.sources.flatMap(({ name, ticket, tone }) => (ticket ? [] : [{ name, tone: tone ?? null }])),
+  sourceLabels: Object.fromEntries(config.watch.sources.map(({ name, label }) => [name, label ?? name])),
+  tones: config.plans.tones,
 })
 
 /** The herd's slice of `.jackherd/config.json`, validated by the shared schema. */