jackherd 1.9.0 → 1.11.0

package/src/plans/settings.ts

@@ -3,13 +3,14 @@ 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
 
 export type PlansSettings = Pick<
   JackherdConfig,
-  'planDirectory' | 'board' | 'worktreeDirectory' | 'baseBranch' | 'planLanguage' | 'responseLanguage'
+  'planDirectory' | 'board' | 'worktreeDirectory' | 'baseBranch' | 'planLanguage' | 'responseLanguage' | 'skillPrefix'
 > & {
   adapter: JackherdConfig['terminal']['adapter']
   fetchIntervalMinutes: number
@@ -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. */
@@ -30,6 +37,7 @@ export const plansSettingsOf = (config: JackherdConfig): PlansSettings => ({
   baseBranch: config.baseBranch,
   planLanguage: config.planLanguage,
   responseLanguage: config.responseLanguage,
+  skillPrefix: config.skillPrefix,
   adapter: config.terminal.adapter,
   fetchIntervalMinutes: config.plans.fetchIntervalMinutes,
   linkKinds: config.plans.linkKinds,
@@ -37,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. */

package/src/plans/signalled-phase.ts

@@ -0,0 +1,42 @@
+import { isPhaseOpen, type PhaseProgress, phaseLabel } from '../plan-format'
+import type { ActiveTask } from './active-tasks'
+
+/** `p24e` in a branch name, standing alone between separators: `feat/jackherd-p24e-task-signal`. */
+const BRANCH_PHASE = /(?:^|[^a-z0-9])p(\d+[a-z]?)(?![a-z0-9])/i
+
+/** The phase id a lane branch names (`feat/jackherd-p24e-task-signal` → `24e`); null for none. */
+export const branchPhaseId = (branch: string | null): string | null =>
+  branch?.match(BRANCH_PHASE)?.[1]?.toLowerCase() ?? null
+
+const newestStart = (tasks: readonly ActiveTask[]): number => Math.max(...tasks.map(({ startedAt }) => startedAt ?? 0))
+
+/** The open phase with the newest task an agent reported; null when no open phase has one. */
+const reportedPhase = (
+  phases: readonly PhaseProgress[],
+  reported: ReadonlyMap<string, readonly ActiveTask[]>,
+): PhaseProgress | null =>
+  phases
+    .filter((phase) => isPhaseOpen(phase) && (reported.get(phase.id)?.length ?? 0) > 0)
+    .reduce<PhaseProgress | null>(
+      (best, phase) =>
+        best && newestStart(reported.get(best.id) ?? []) >= newestStart(reported.get(phase.id) ?? []) ? best : phase,
+      null,
+    )
+
+/**
+ * The phase the lane says it works on (D112): the open phase with the newest reported task, else the open phase its
+ * branch names (`branchPhaseId`); null otherwise, and the ticks decide as before. A phase ticked to the end is never
+ * signalled, so a stale report or an old branch name cannot make finished work current.
+ */
+export const signalledPhase = (
+  phases: readonly PhaseProgress[],
+  reported: ReadonlyMap<string, readonly ActiveTask[]>,
+  branch: string | null,
+): PhaseProgress | null => {
+  const id = branchPhaseId(branch)
+  return reportedPhase(phases, reported) ?? phases.find((phase) => phase.id === id && isPhaseOpen(phase)) ?? null
+}
+
+/** The sidebar title of a lane: the signalled phase as `P24d · 1/5`, else `fromProgress` (`shortTitle`). */
+export const signalledTitle = (signalled: PhaseProgress | null, fromProgress: string | null): string | null =>
+  signalled ? `${phaseLabel(signalled.id)} · ${signalled.done}/${signalled.total}` : fromProgress

package/src/plans/signals-read.ts

@@ -2,7 +2,8 @@ import { readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { projectDirectoryOf } from '../context/session-log'
 import { MS_PER_MINUTE } from '../plan-format/clock'
-import { readClaudeSignals } from '../task-signals/claude-read'
+import { dropUnused, type StatCache } from '../shared/stat-cache'
+import { readClaudeSignals, type SignalCache } from '../task-signals/claude-read'
 import { recordSignals } from '../task-signals/record'
 import { readTaskRecords } from '../task-signals/record-store'
 import type { TaskSignal } from '../task-signals/types'
@@ -41,14 +42,21 @@ const recentSessionLogs = (project: string, notOlderThan: number): string[] => {
 /**
  * What agents report doing, as `TaskSignal`s: the tasks in progress in the recent Claude Code sessions of the main
  * checkout (the coordinator and its subagents) and of every worktree, and the open `jh task` records. Which lane a
- * signal belongs to is decided by its `cwd`, not by where it was read.
+ * signal belongs to is decided by its `cwd`, not by where it was read. A `cache` kept between calls spares parsing a
+ * log whose modification time and size did not change; logs this call did not look at are dropped from it.
  */
-export const readAllSignals = ({ projects, root, worktrees }: SignalSource, now: number): TaskSignal[] => {
+export const readAllSignals = (
+  { projects, root, worktrees }: SignalSource,
+  now: number,
+  cache: StatCache<TaskSignal[]> = new Map(),
+): TaskSignal[] => {
   const notOlderThan = now - STALE_ACTIVITY_MINUTES * MS_PER_MINUTE
+  const round: SignalCache = { entries: cache, used: new Set<string>() }
   const claude = [root, ...subdirectories(worktrees)].flatMap((directory) =>
     recentSessionLogs(join(projects, projectDirectoryOf(directory)), notOlderThan).flatMap((path) =>
-      readClaudeSignals(path, { notOlderThan }),
+      readClaudeSignals(path, { notOlderThan, cache: round }),
     ),
   )
+  dropUnused(round.entries, round.used)
   return [...claude, ...recordSignals(readTaskRecords(root))]
 }

package/src/plans/snapshot.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import type { ContextReading } from '../context'
 import { type AgentLogReader, contextOfAgent } from '../context/report'
@@ -13,12 +13,18 @@ import {
   shortTitle,
   sprintTitleOf,
 } from '../plan-format'
-import { openWaitingItems, type WaitingItem } from '../plan-format/waiting'
+import type { WaitingItem } from '../plan-format/waiting'
+import { dropUnused } from '../shared/stat-cache'
 import type { TaskSignal } from '../task-signals/types'
 import type { LaneAgent, LaneStatusSource } from '../terminal'
+import { isRestingAgent } from '../terminal/types'
+import { laneReportPath, readLaneReport } from '../watch/lane-report-file'
+import { restNote } from '../watch/lane-rest'
 import type { SourceTicket, WatchBadges, WatchHealth } from '../watch/plan-badges'
 import { readWatchReading } from '../watch/plan-badges-read'
+import type { SourceStatus } from '../watch/source-statuses'
 import { assignSignals, laneOfDirectory, type UnplannedTask } from './active-tasks'
+import { type AppointmentBlock, appointmentBlock } from './appointment-rows'
 import { boardRowsOf } from './board-rows'
 import {
   type ActivityTimes,
@@ -31,25 +37,41 @@ import {
 } from './current-phase'
 import { activityTextOf, taskSignalsOf } from './current-task'
 import { errorText } from './error-text'
-import { type BaseReader, baseReaderOf, gitStatusOf, refExists } from './git'
+import { type BaseReader, baseReaderOf, gitStatusOf, lastChangeReaderOf, refExists } from './git'
 import type { PullRequestState } from './github'
-import { type Fallbacks, laneWorkOf, readAtBase, readFallback, readPlans, textAtBase } from './lane-plans'
+import { groomedDaysAgo } from './groomed'
+import {
+  type Fallbacks,
+  laneWorkOf,
+  type PlanSources,
+  readAtBase,
+  readFallback,
+  readPlans,
+  textAtBase,
+} from './lane-plans'
 import { laneSummary } from './lane-summary'
 import { boardRowTexts, laneTicketsOf, withoutTicketLinks } from './lane-tickets'
 import type { LaneView } from './layout'
 import { extractLinkChips } from './link-chips'
+import { type NextBlock, nextBlock } from './next-rows'
 import type { Options } from './options'
 import { laneModelsOf, type PhaseModelRecord } from './phase-models'
 import { readPhaseModels } from './phase-models-read'
-import { type PlannedPlan, plannedPlans } from './planned'
-import { type SentChip, type SentFileRecord, sentChipsByLane, sentWaitingItems } from './sent-files'
-import { readSentRecords } from './sent-files-read'
+import { laneHeads, planPullRequests, readerOncePerRef } from './plan-heads'
+import { markStale, type PlannedPlan, plannedPlans } from './planned'
+import type { PullRequest } from './pull-requests'
+import type { ReadCache } from './read-cache'
+import { type SentChip, sentChipsByLane } from './sent-files'
 import { baseRefOf, boardRepoPathOf, type PlansSettings, worktreeOf } from './settings'
+import { signalledTitle } from './signalled-phase'
 import { readAllSignals } from './signals-read'
+import { withSourcePrefix } from './source-prefix'
+import type { HerdSource, SourceBlock } from './source-rows'
 import type { SubagentActivity } from './subagents'
-import { readSubagentActivity } from './subagents-read'
+import { readSubagentActivity, subagentSourceOf } from './subagents-read'
 import { boardTexts } from './texts'
 import { type UnlistedLane, unlistedLanes, unlistedSprintLane } from './unlisted-lanes'
+import { readWaitingRecords, waitingItemsOf } from './waiting-records'
 import { withWorkedPhases } from './worked-phases'
 
 /** Where the view reads from: the main checkout, the sprint document, the command line and the project settings. */
@@ -101,6 +123,16 @@ export type Snapshot = {
   watchesTickets?: boolean
   /** What waits on the user's answer: the open rows of the board's section for it, from the checkout's board file. */
   waiting?: WaitingItem[]
+  /** Whole days since the board's grooming (`groomedDaysAgo`); null when its appointment is missing. */
+  groomedDays?: number | null
+  /** The board's next section, read from the same board text as `waiting`, for the block under it. */
+  next?: NextBlock
+  /** The board's open appointments, read from the same board text as `waiting`, for the block under the next one. */
+  appointments?: AppointmentBlock
+  /** The sources of `watch.sources` not marked `ticket`, from the watcher's state, for the block under the appointments. */
+  sourceBlock?: SourceBlock
+  /** The tone of each role, from the config, which `renderSnapshot` sets before it draws. */
+  tones?: PlansSettings['tones']
   /** What agents report doing that no lane takes: the coordinator's own, or a lane the board does not list. */
   unplaced?: UnplannedTask[]
 }
@@ -115,13 +147,19 @@ type LaneSources = {
   /** The agents' log reader, asking once per agent however often the read is used in one snapshot. */
   readLog: AgentLogReader
   pullRequests: PullRequestState
+  /** The open pull requests that change a plan, whose heads raise the ticks the base ref has. */
+  planPullRequests: PullRequest[]
+  /** The reader of a pull request head, resolved once per read whatever the number of lanes. */
+  headReaderOf: (ref: string) => BaseReader
   /** What agents report doing, in every lane and outside them. */
   signals: TaskSignal[]
   /** The directory the lanes' worktrees lie in, which tells a signal's lane. */
   worktrees: string
+  parsed?: PlanSources['parsed']
 }
 
-type BoardLanes = { markdown: string; lanes: SprintLane[] }
+/** `liveMarkdown` is the checkout's board file (the coordinator edits it before any commit), else `markdown`. */
+type BoardLanes = { markdown: string; liveMarkdown: string; lanes: SprintLane[] }
 
 const SHOWN_NAMES = 2
 
@@ -136,6 +174,7 @@ type Decorations = {
   phaseModels: readonly PhaseModelRecord[]
   sprintDirectory: string
   sentChips: ReadonlyMap<string | null, SentChip[]>
+  restNoteOf: (lane: string) => string | null
 }
 
 /** How full the agent's context is, null when the terminal gave no session or the session has no log. */
@@ -219,12 +258,20 @@ const laneView = async (
     modified,
   } = await readPlans(
     lane,
-    { root, settings, base: sources.base, sprintDirectory: sources.sprintDirectory },
+    {
+      root,
+      settings,
+      base: sources.base,
+      sprintDirectory: sources.sprintDirectory,
+      heads: laneHeads(sources.planPullRequests, gitStatus.branch, sources.headReaderOf),
+      parsed: sources.parsed,
+    },
     laneWorkOf(worktree, gitStatus),
     fallbacks,
   )
   const shown = withWorkedPhases(lane, phasesByHref)
   const { progress, activity } = progressWithMemory(shown, phasesByHref, memories, { now, modified })
+  const laneSubagents = sources.subagents.get(lane.name)
   const view: LaneView = {
     progress,
     ...running,
@@ -238,6 +285,11 @@ const laneView = async (
         activity,
         guesses: taskSignalsOf(Object.values(phasesByHref).flat(), workText(sources, lane.name, agent), now),
         reported: sources.signals.filter(({ cwd }) => laneOfDirectory(cwd, sources.worktrees) === lane.name),
+        subagents: laneSubagents?.phaseRuns ?? [],
+        subagentTasks: laneSubagents?.taskDescriptions ?? [],
+        phaselessReviews: laneSubagents?.phaselessReviews ?? [],
+        describedSubagents: laneSubagents?.describedSubagents ?? [],
+        branch: gitStatus.branch,
       },
       now,
     ),
@@ -289,12 +341,17 @@ const withTickets = (result: LaneResult, tickets: readonly SourceTicket[]): Lane
 }
 
 /** What agents report doing; nothing when it cannot be read. */
-const readSignals = ({ root, readSignals: read }: Source, worktrees: string, now: number): TaskSignal[] => {
+const readSignals = (
+  { root, readSignals: read }: Source,
+  worktrees: string,
+  now: number,
+  cache?: ReadCache,
+): TaskSignal[] => {
   try {
     return (
       read ??
       ((main, directory, at) =>
-        readAllSignals({ projects: defaultProjectsDirectory(), root: main, worktrees: directory }, at))
+        readAllSignals({ projects: defaultProjectsDirectory(), root: main, worktrees: directory }, at, cache?.signals))
     )(root, worktrees, now)
   } catch {
     return []
@@ -322,52 +379,31 @@ const readAgents = (terminal: LaneStatusSource): { agents: LaneAgent[]; errors:
 }
 
 /** What subagents of the coordinator do in the worktrees; nothing when their logs cannot be read. */
-const readSubagents = ({ root, readSubagents: read }: Source, worktrees: string): Map<string, SubagentActivity> => {
+const readSubagents = (
+  { root, settings, readSubagents: read }: Source,
+  worktrees: string,
+): Map<string, SubagentActivity> => {
   try {
     return (
-      read ??
-      ((main, directory) =>
-        readSubagentActivity({
-          projects: defaultProjectsDirectory(),
-          root: main,
-          approvalsRoot: main,
-          worktreeDirectory: directory,
-        }))
+      read ?? ((main, directory) => readSubagentActivity(subagentSourceOf(main, directory, settings.skillPrefix)))
     )(root, worktrees)
   } catch {
     return new Map()
   }
 }
 
-/**
- * The open items that wait on the user, from the checkout's board file (the coordinator edits it before any commit),
- * else from the text read at the base ref.
- */
-const waitingOf = (
-  { sprintFile, settings }: Source,
-  markdown: string,
-  sends: readonly SentFileRecord[],
-  now: number,
-): WaitingItem[] => {
-  const board = (() => {
-    try {
-      return openWaitingItems(
-        existsSync(sprintFile) ? readFileSync(sprintFile, 'utf8') : markdown,
-        settings.planLanguage,
-      )
-    } catch {
-      return openWaitingItems(markdown, settings.planLanguage)
-    }
-  })()
-  return [...board, ...sentWaitingItems(sends, now)]
-}
-
 /** The view with the files its session sent to the user, only when there are any, so it otherwise stays as it was. */
 const withSentFiles = (view: LaneView, chips: ReadonlyMap<string | null, SentChip[]>): LaneView => {
   const found = chips.get(view.progress.lane.name)
   return found ? { ...view, sentFiles: found } : view
 }
 
+/** The view with what its resting lane waits on, read from the lane's report as the watcher reads it; as it was while the agent works. */
+const withRestNote = (view: LaneView, restNoteOf: Decorations['restNoteOf']): LaneView => {
+  const note = isRestingAgent(view.status.agent) ? restNoteOf(view.progress.lane.name) : null
+  return note === null ? view : { ...view, restNote: note }
+}
+
 /** Up to two names, then how many more: `a, b and 3 more`. */
 const namedWithMore = (names: readonly string[]): string => {
   const more = names.length - SHOWN_NAMES
@@ -395,8 +431,8 @@ const readBoardLanes = async (
   const { sprintFile, settings } = source
   const atBase = textAtBase(base, boardPath)
   const markdown = atBase ?? (await readFallback(boardPath, sprintFile, fallbacks)) ?? ''
-  const checkoutText = atBase !== null && existsSync(sprintFile) ? await Bun.file(sprintFile).text() : markdown
-  return { markdown, lanes: boardRowsOf(markdown, checkoutText, settings.planLanguage).lanes }
+  const liveMarkdown = atBase !== null && existsSync(sprintFile) ? await Bun.file(sprintFile).text() : markdown
+  return { markdown, liveMarkdown, lanes: boardRowsOf(markdown, liveMarkdown, settings.planLanguage).lanes }
 }
 
 /** The plans the sprint's plans tables name, read at the base ref, by link; lanes read theirs themselves. */
@@ -429,11 +465,17 @@ const forgetLanes = (memories: Map<string, LaneMemory> | undefined, lanes: reado
 
 const laneSetOf = (
   source: Source,
-  context: { base: BaseReader; board: BoardLanes; sprintDirectory: string; worktrees: string },
+  context: {
+    base: BaseReader
+    board: BoardLanes
+    sprintDirectory: string
+    worktrees: string
+    cache?: ReadCache
+  },
   pullRequests: PullRequestState,
   now: number,
 ): LaneSet => {
-  const { base, board, sprintDirectory, worktrees } = context
+  const { base, board, sprintDirectory, worktrees, cache } = context
   const { agents, errors } = readAgents(source.terminal)
   const isWanted = ({ name }: { name: string }) => !source.options.lane || name === source.options.lane
   const subagents = readSubagents(source, worktrees)
@@ -449,8 +491,11 @@ const laneSetOf = (
       subagents,
       readLog: onceReader(source.readAgentLog ?? agentLog),
       pullRequests,
-      signals: readSignals(source, worktrees, now),
+      planPullRequests: planPullRequests([...pullRequests.byBranch.values()].flat(), source.settings.planDirectory),
+      headReaderOf: readerOncePerRef((ref) => baseReaderOf(source.root, ref)),
+      signals: readSignals(source, worktrees, now, cache),
       worktrees,
+      parsed: cache && { entries: cache.plans, used: new Set<string>() },
     },
     errors,
   }
@@ -474,53 +519,56 @@ const laneResultsOf = async (
 /** Each lane's view with its tickets, the watcher's badges, its phases' models and the files sent from it. */
 const decoratedViews = (
   results: readonly LaneResult[],
-  { reading, phaseModels, sprintDirectory, sentChips }: Decorations,
+  { reading, phaseModels, sprintDirectory, sentChips, restNoteOf }: Decorations,
 ): LaneView[] =>
   results.map((result) =>
-    withSentFiles(
-      withModels(
-        withBadges(withTickets(result, reading?.tickets ?? []), reading?.badges ?? {}),
-        phaseModels,
-        sprintDirectory,
+    withRestNote(
+      withSentFiles(
+        withModels(
+          withBadges(withTickets(result, reading?.tickets ?? []), reading?.badges ?? {}),
+          phaseModels,
+          sprintDirectory,
+        ),
+        sentChips,
       ),
-      sentChips,
+      restNoteOf,
     ),
   )
 
-/** The files sent to the user, read once: the records, and their badges by lane. */
-const sendsOf = (
-  root: string,
-  worktrees: string,
-  now: number,
-): { records: SentFileRecord[]; chips: Map<string | null, SentChip[]> } => {
-  const records = readSentRecords(root)
-  return { records, chips: sentChipsByLane(records, worktrees, now) }
-}
-
 /** The open phases no lane with an agent leads; none while the view shows one lane. */
+const withSourceTones = (statuses: readonly SourceStatus[], configured: PlansSettings['herdSources']): HerdSource[] =>
+  statuses.map((status) => ({ ...status, tone: configured.find(({ name }) => name === status.name)?.tone ?? null }))
+
 const plannedOf = (
   source: Source,
   plans: Record<string, string>,
   results: readonly LaneResult[],
   sprintDirectory: string,
+  now: number,
 ): PlannedPlan[] =>
   source.options.lane
     ? []
-    : plannedPlans({
-        plans,
-        lanes: results.map(({ view }) => ({ lane: view.progress.lane, agent: view.status.agent })),
-        sprintDirectory,
-        language: source.settings.planLanguage,
-      })
+    : markStale(
+        plannedPlans({
+          plans,
+          lanes: results.map(({ view }) => ({ lane: view.progress.lane, agent: view.status.agent })),
+          sprintDirectory,
+          language: source.settings.planLanguage,
+        }),
+        lastChangeReaderOf(source.root, baseRefOf(source.settings)),
+        now,
+      )
 
 /**
  * Reads the board, its plans and the lanes' state. `memories` holds, per lane, what the herd saw at the last read; it
  * is how the current phase becomes the one whose boxes moved since, and it is cleaned of lanes the board dropped.
+ * `cache`, kept by the caller between reads, spares parsing the session logs and plans that did not change.
  */
 export const loadSnapshot = async (
   source: Source,
   pullRequests: PullRequestState,
   memories?: Map<string, LaneMemory>,
+  cache?: ReadCache,
 ): Promise<Snapshot> => {
   const { root, sprintFile, options, settings } = source
   const fallbacks: Fallbacks = []
@@ -532,14 +580,32 @@ export const loadSnapshot = async (
   const sprintDirectory = dirname(boardPath)
   const worktrees = join(root, settings.worktreeDirectory)
   const now = Date.now()
-  const laneSet = laneSetOf(source, { base, board, sprintDirectory, worktrees }, pullRequests, now)
+  const liveBoard = board.liveMarkdown
+  const laneSet = laneSetOf(source, { base, board, sprintDirectory, worktrees, cache }, pullRequests, now)
   const results = await laneResultsOf(laneSet, fallbacks, now, memories)
+  const { parsed } = laneSet.sources
+  if (parsed) dropUnused(parsed.entries, parsed.used)
   const listedPlans = await readListedPlans(source, base, sprintDirectory, markdown, fallbacks)
   const documentsPlans = Object.assign({}, listedPlans, ...results.map((result) => result.texts))
-  const { ticketSources } = settings
-  const watched = ticketSources.length > 0 || results.some(({ view }) => view.pullRequests.length > 0)
-  const reading = watched ? readWatchReading(root, now, ticketSources) : null
-  const sends = sendsOf(root, worktrees, now)
+  const { ticketSources, herdSources } = settings
+  const watched =
+    ticketSources.length > 0 || herdSources.length > 0 || results.some(({ view }) => view.pullRequests.length > 0)
+  const reading = watched
+    ? readWatchReading(
+        root,
+        now,
+        ticketSources,
+        undefined,
+        undefined,
+        herdSources.map(({ name }) => name),
+      )
+    : null
+  const waitingRecords = readWaitingRecords(root)
+  const waiting = withSourcePrefix(
+    waitingItemsOf(liveBoard, settings.planLanguage, waitingRecords, now),
+    settings.sourceLabels,
+  )
+  const sentChips = sentChipsByLane(waitingRecords.sent, worktrees, now)
   const notice = fallbacks.length > 0 ? fallbackNotice(fallbacks, baseRef, refExists(root, baseRef)) : null
   const unknownLaneTitle =
     options.lane && results.length === 0 ? boardTexts(settings.board.term).laneNotListed(options.lane) : null
@@ -549,7 +615,9 @@ export const loadSnapshot = async (
       reading,
       phaseModels: readPhaseModels(root),
       sprintDirectory,
-      sentChips: sends.chips,
+      sentChips,
+      restNoteOf: (lane) =>
+        restNote(readLaneReport(laneReportPath(worktreeOf(root, settings, lane), lane))?.text ?? null),
     }),
     documents: {
       sprint: markdown,
@@ -557,12 +625,25 @@ export const loadSnapshot = async (
       laneOrder: [...laneSet.lanes, ...laneSet.unlisted].map((lane) => lane.name),
       lanes: board.lanes,
     },
-    planned: plannedOf(source, documentsPlans, results, sprintDirectory),
+    planned: plannedOf(source, documentsPlans, results, sprintDirectory, now),
     files: [sprintFile, ...results.flatMap((result) => result.files)],
-    titles: new Map(results.flatMap(({ view, pane }) => (pane ? [[pane, shortTitle(view.progress)]] : []))),
+    titles: new Map(
+      results.flatMap(({ view, pane }) =>
+        pane ? [[pane, signalledTitle(view.summary?.signalled ?? null, shortTitle(view.progress))]] : [],
+      ),
+    ),
     errors: [...laneSet.errors, ...pullRequests.errors, ...(notice ? [notice] : [])],
     watch: reading?.health,
-    waiting: waitingOf(source, markdown, sends.records, now),
+    waiting,
+    groomedDays: groomedDaysAgo(liveBoard, settings.planLanguage, new Date(now)),
+    next: nextBlock(
+      liveBoard,
+      settings.planLanguage,
+      waiting.map(({ item }) => item),
+    ),
+    appointments: appointmentBlock(liveBoard, settings.planLanguage, new Date(now)),
+    ...(reading?.sources ? { sourceBlock: { sources: withSourceTones(reading.sources, herdSources), now } } : {}),
+    tones: settings.tones,
     unplaced: unplacedOf(laneSet.sources, laneSet.lanes, Boolean(options.lane)),
     ...(ticketSources.length > 0 ? { watchesTickets: true } : {}),
   }

package/src/plans/source-asked.ts

@@ -0,0 +1,19 @@
+import type { WaitingItem } from '../plan-format/waiting'
+
+/** Whether the source `source` has an entry titled `title` that an open row of "Waiting for you" asks about. */
+export type AskedCheck = (source: string, title: string) => boolean
+
+const same = (left: string, right: string): boolean => left.trim().toLowerCase() === right.trim().toLowerCase()
+
+/**
+ * The check against the open rows: a row asks about an entry when its origin cell names the entry's source and its text
+ * contains the entry's title, in any case. The rows come from the board, whose text names the entry in words; no id links them.
+ */
+export const askedCheckOf =
+  (waiting: readonly WaitingItem[]): AskedCheck =>
+  (source, title) =>
+    title.trim() !== '' &&
+    waiting.some(
+      ({ origin, item }) =>
+        origin !== undefined && same(origin, source) && item.toLowerCase().includes(title.trim().toLowerCase()),
+    )

package/src/plans/source-prefix.ts

@@ -0,0 +1,17 @@
+import type { WaitingItem } from '../plan-format/waiting'
+
+/** By source name in lower case: what the herd puts before a row that came from the source, its `label` or else its name. */
+export type SourceLabels = Readonly<Record<string, string>>
+
+const lookup = (labels: SourceLabels, origin: string): string | undefined =>
+  Object.entries(labels).find(([name]) => name.toLowerCase() === origin.trim().toLowerCase())?.[1]
+
+/**
+ * The rows with `prefix` set on those whose origin cell names a source: the board row of a source's report then
+ * reads `Error log · Checkout: Resource Not Found` without a look at the plan. Any other row stays as it is.
+ */
+export const withSourcePrefix = (items: readonly WaitingItem[], labels: SourceLabels): WaitingItem[] =>
+  items.map((item) => {
+    const prefix = item.origin === undefined ? undefined : lookup(labels, item.origin)
+    return prefix === undefined ? item : { ...item, prefix }
+  })