jackherd 1.11.1 → 1.12.0

package/src/plans/snapshot.ts

@@ -24,8 +24,7 @@ import type { SourceTicket, WatchBadges, WatchHealth } from '../watch/plan-badge
 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 BoardRowsReader, boardRowsOf } from './board-rows'
 import {
   type ActivityTimes,
   type LaneMemory,
@@ -37,7 +36,17 @@ import {
 } from './current-phase'
 import { activityTextOf, taskSignalsOf } from './current-task'
 import { errorText } from './error-text'
-import { type BaseReader, baseReaderOf, gitStatusOf, lastChangeReaderOf, refExists } from './git'
+import {
+  type BaseReader,
+  type BranchStatusReader,
+  baseReaderAt,
+  branchStatusAt,
+  gitStatusOf,
+  lastChangesAt,
+  refCommits,
+  refExists,
+  resolveCommit,
+} from './git'
 import type { PullRequestState } from './github'
 import { groomedDaysAgo } from './groomed'
 import {
@@ -53,26 +62,30 @@ 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 { laneHeads, planPullRequests, readerOncePerRef } from './plan-heads'
+import { parsedPlanPhases } from './plan-cache'
+import { laneHeads, PULL_HEAD_NAMESPACE, 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 { readAllSignalsSliced } from './signals-read'
+import { createSliceGate, type SliceGate } from './slice-gate'
 import { withSourcePrefix } from './source-prefix'
 import type { HerdSource, SourceBlock } from './source-rows'
+import { type KeptStatus, logMark, pacedStatus } from './status-pace'
 import type { SubagentActivity } from './subagents'
-import { readSubagentActivity, subagentSourceOf } from './subagents-read'
+import { readSubagentActivitySliced, 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'
+import { worktreeStamp } from './worktree-stamp'
+import { type YourTurnBlock, yourTurnOfBoard } from './your-turn'
 
 /** Where the view reads from: the main checkout, the sprint document, the command line and the project settings. */
 export type Source = {
@@ -81,6 +94,8 @@ export type Source = {
   options: Options
   settings: PlansSettings
   terminal: LaneStatusSource
+  /** The terminal's agents without holding the event loop; defaults to `terminal.listAgents`, which does. */
+  listAgents?: () => Promise<LaneAgent[]>
   /** The log lines of an agent's chat, null without one; defaults to reading them from `~/.claude/projects`. */
   readAgentLog?: AgentLogReader
   /** The worktrees subagents of the coordinator work in; defaults to reading them from `~/.claude/projects`. */
@@ -125,11 +140,9 @@ export type Snapshot = {
   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. */
+  /** What is the user's turn: `waiting`, the board's open appointments and its next section, one row per topic. */
+  yourTurn?: YourTurnBlock
+  /** The sources of `watch.sources` not marked `ticket`, from the watcher's state, for the block under "Your turn". */
   sourceBlock?: SourceBlock
   /** The tone of each role, from the config, which `renderSnapshot` sets before it draws. */
   tones?: PlansSettings['tones']
@@ -156,6 +169,12 @@ type LaneSources = {
   /** The directory the lanes' worktrees lie in, which tells a signal's lane. */
   worktrees: string
   parsed?: PlanSources['parsed']
+  /** The gate each lane passes before a piece of synchronous work, so the lanes take turns with keys and drawing. */
+  gate: SliceGate
+  /** Each worktree's last `git status`, kept between the herd's reads; absent for a single read, which asks git. */
+  statuses?: Map<string, KeptStatus>
+  /** When this read happens, epoch milliseconds. */
+  now: number
 }
 
 /** `liveMarkdown` is the checkout's board file (the coordinator edits it before any commit), else `markdown`. */
@@ -163,6 +182,12 @@ type BoardLanes = { markdown: string; liveMarkdown: string; lanes: SprintLane[]
 
 const SHOWN_NAMES = 2
 
+/**
+ * How long a read keeps the event loop before it lets keys, mouse and drawing in: a quarter frame at 60 Hz, so a slice
+ * and the longest single step after it stay within one frame.
+ */
+const SLICE_MS = 4
+
 type LaneResult = { view: LaneView; files: string[]; texts: Record<string, string>; pane: string | null }
 
 /** The board's lanes the view shows, the running lanes it does not list, and what the lanes read from. */
@@ -177,9 +202,30 @@ type Decorations = {
   restNoteOf: (lane: string) => string | null
 }
 
+/** What every answer line of a session log holds; the fill is read from answers only. */
+const ANSWER_MARK = '"type":"assistant"'
+
+const answerLines = new WeakMap<readonly string[], string[]>()
+
+/**
+ * The lines of a log that can be answers, kept per log as read: a log that did not change comes back as the same
+ * array (`followTailLines`), so its lines are not searched again, and the fill parses a few lines, not the whole tail.
+ */
+const answerLinesOf = (lines: readonly string[]): string[] => {
+  const kept = answerLines.get(lines)
+  if (kept) return kept
+  const found = lines.filter((line) => line.includes(ANSWER_MARK))
+  answerLines.set(lines, found)
+  return found
+}
+
 /** How full the agent's context is, null when the terminal gave no session or the session has no log. */
 const contextOf = (agent: LaneAgent | undefined, source: Source, readLog: AgentLogReader): ContextReading | null => {
-  const report = contextOfAgent(agent, readLog, source.settings.context)
+  const readAnswers: AgentLogReader = (asked) => {
+    const lines = readLog(asked)
+    return lines && answerLinesOf(lines)
+  }
+  const report = contextOfAgent(agent, readAnswers, source.settings.context)
   return report && { share: report.share, level: report.level }
 }
 
@@ -201,17 +247,35 @@ const workText = ({ readLog, subagents }: LaneSources, lane: string, agent: Lane
   return [lines ? activityTextOf(lines, WORK_ENTRIES) : '', subagents.get(lane)?.activity ?? ''].join(' ')
 }
 
+/**
+ * `git status` of a lane's worktree asked only when something there may have moved: its index or HEAD, its agent's
+ * log or its subagents' work (`worktreeStamp`), or the kept answer is old; git every time without kept statuses.
+ */
+const pacedStatusReader = (sources: LaneSources, name: string, agent: LaneAgent | undefined): BranchStatusReader => {
+  const { statuses, now } = sources
+  if (!statuses) return branchStatusAt
+  return (worktree, pass) => {
+    const activity = `${logMark(agent ? sources.readLog(agent) : null)}|${sources.subagents.get(name)?.activity ?? ''}`
+    const ask = { worktree, stamp: worktreeStamp(worktree, activity), now }
+    return pacedStatus(statuses, ask, () => branchStatusAt(worktree, pass))
+  }
+}
+
 /** What a lane's worktree and agent say, listed in the sprint or not: git state, pull requests, context. */
 const runningState = async (sources: LaneSources, name: string, agent: LaneAgent | undefined) => {
   const { source, pullRequests } = sources
-  const gitStatus = await gitStatusOf(worktreeOf(source.root, source.settings, name), baseRefOf(source.settings))
+  const gitStatus = await gitStatusOf(
+    worktreeOf(source.root, source.settings, name),
+    baseRefOf(source.settings),
+    sources.gate.pass,
+    pacedStatusReader(sources, name, agent),
+  )
+  await sources.gate.pass()
   const subagent = agent ? undefined : sources.subagents.get(name)
-  const title = agent?.title ?? subagent?.description
   return {
     gitStatus,
     view: {
       status: { agent: agent?.status ?? subagent?.status ?? null, ...gitStatus },
-      ...(title ? { sessionTitle: title } : {}),
       pullRequests: gitStatus.branch ? (pullRequests.byBranch.get(gitStatus.branch) ?? []) : [],
       context: contextOf(agent, source, sources.readLog),
     },
@@ -248,6 +312,7 @@ const laneView = async (
 ): Promise<LaneResult> => {
   const { source, agents } = sources
   const { root, settings } = source
+  await sources.gate.pass()
   const worktree = worktreeOf(root, settings, lane.name)
   const agent = agents.find((candidate) => candidate.name === lane.name)
   const { gitStatus, view: running } = await runningState(sources, lane.name, agent)
@@ -269,6 +334,7 @@ const laneView = async (
     laneWorkOf(worktree, gitStatus),
     fallbacks,
   )
+  await sources.gate.pass()
   const shown = withWorkedPhases(lane, phasesByHref)
   const { progress, activity } = progressWithMemory(shown, phasesByHref, memories, { now, modified })
   const laneSubagents = sources.subagents.get(lane.name)
@@ -340,19 +406,16 @@ const withTickets = (result: LaneResult, tickets: readonly SourceTicket[]): Lane
   return found ? { ...view, chips: withoutTicketLinks(view.chips, found), tickets: found } : view
 }
 
-/** What agents report doing; nothing when it cannot be read. */
-const readSignals = (
+/** What agents report doing, one log per slice of `gate`; nothing when it cannot be read. */
+const readSignals = async (
   { root, readSignals: read }: Source,
-  worktrees: string,
-  now: number,
-  cache?: ReadCache,
-): TaskSignal[] => {
+  context: { worktrees: string; now: number; gate: SliceGate; cache?: ReadCache },
+): Promise<TaskSignal[]> => {
+  const { worktrees, now, gate, cache } = context
   try {
-    return (
-      read ??
-      ((main, directory, at) =>
-        readAllSignals({ projects: defaultProjectsDirectory(), root: main, worktrees: directory }, at, cache?.signals))
-    )(root, worktrees, now)
+    if (read) return read(root, worktrees, now)
+    const source = { projects: defaultProjectsDirectory(), root, worktrees }
+    return await readAllSignalsSliced(source, now, cache?.signals ?? new Map(), gate.pass)
   } catch {
     return []
   }
@@ -370,23 +433,23 @@ const unplacedOf = (sources: LaneSources, lanes: readonly SprintLane[], onlyLane
 }
 
 /** The terminal's agents, or none with the reason when it cannot be asked, so the screen says why lanes show "no agent". */
-const readAgents = (terminal: LaneStatusSource): { agents: LaneAgent[]; errors: string[] } => {
+const readAgents = async ({ terminal, listAgents }: Source): Promise<{ agents: LaneAgent[]; errors: string[] }> => {
   try {
-    return { agents: terminal.listAgents(), errors: [] }
+    return { agents: listAgents ? await listAgents() : terminal.listAgents(), errors: [] }
   } catch (error) {
     return { agents: [], errors: [errorText(error)] }
   }
 }
 
-/** What subagents of the coordinator do in the worktrees; nothing when their logs cannot be read. */
-const readSubagents = (
+/** What subagents of the coordinator do in the worktrees, one session per slice of `gate`; nothing when their logs cannot be read. */
+const readSubagents = async (
   { root, settings, readSubagents: read }: Source,
   worktrees: string,
-): Map<string, SubagentActivity> => {
+  gate: SliceGate,
+): Promise<Map<string, SubagentActivity>> => {
   try {
-    return (
-      read ?? ((main, directory) => readSubagentActivity(subagentSourceOf(main, directory, settings.skillPrefix)))
-    )(root, worktrees)
+    if (read) return read(root, worktrees)
+    return await readSubagentActivitySliced(subagentSourceOf(root, worktrees, settings.skillPrefix), gate.pass)
   } catch {
     return new Map()
   }
@@ -427,12 +490,13 @@ const readBoardLanes = async (
   base: BaseReader,
   boardPath: string,
   fallbacks: Fallbacks,
+  rowsOf: BoardRowsReader,
 ): Promise<BoardLanes> => {
   const { sprintFile, settings } = source
   const atBase = textAtBase(base, boardPath)
   const markdown = atBase ?? (await readFallback(boardPath, sprintFile, fallbacks)) ?? ''
   const liveMarkdown = atBase !== null && existsSync(sprintFile) ? await Bun.file(sprintFile).text() : markdown
-  return { markdown, liveMarkdown, lanes: boardRowsOf(markdown, liveMarkdown, settings.planLanguage).lanes }
+  return { markdown, liveMarkdown, lanes: rowsOf(markdown, liveMarkdown, settings.planLanguage).lanes }
 }
 
 /** The plans the sprint's plans tables name, read at the base ref, by link; lanes read theirs themselves. */
@@ -463,7 +527,7 @@ const forgetLanes = (memories: Map<string, LaneMemory> | undefined, lanes: reado
   for (const name of [...(memories?.keys() ?? [])]) if (!names.has(name)) memories?.delete(name)
 }
 
-const laneSetOf = (
+const laneSetOf = async (
   source: Source,
   context: {
     base: BaseReader
@@ -471,14 +535,19 @@ const laneSetOf = (
     sprintDirectory: string
     worktrees: string
     cache?: ReadCache
+    gate: SliceGate
   },
   pullRequests: PullRequestState,
   now: number,
-): LaneSet => {
-  const { base, board, sprintDirectory, worktrees, cache } = context
-  const { agents, errors } = readAgents(source.terminal)
+): Promise<LaneSet> => {
+  const { base, board, sprintDirectory, worktrees, cache, gate } = context
+  await gate.pass()
+  const { agents, errors } = await readAgents(source)
   const isWanted = ({ name }: { name: string }) => !source.options.lane || name === source.options.lane
-  const subagents = readSubagents(source, worktrees)
+  const subagents = await readSubagents(source, worktrees, gate)
+  const signals = await readSignals(source, { worktrees, now, gate, cache })
+  const planPulls = planPullRequests([...pullRequests.byBranch.values()].flat(), source.settings.planDirectory)
+  const headCommits = planPulls.length > 0 ? await refCommits(source.root, PULL_HEAD_NAMESPACE) : new Map()
   const listed = new Set(board.lanes.map((lane) => lane.name))
   return {
     lanes: board.lanes.filter(isWanted),
@@ -491,11 +560,14 @@ const laneSetOf = (
       subagents,
       readLog: onceReader(source.readAgentLog ?? agentLog),
       pullRequests,
-      planPullRequests: planPullRequests([...pullRequests.byBranch.values()].flat(), source.settings.planDirectory),
-      headReaderOf: readerOncePerRef((ref) => baseReaderOf(source.root, ref)),
-      signals: readSignals(source, worktrees, now, cache),
+      planPullRequests: planPulls,
+      headReaderOf: readerOncePerRef((ref) => baseReaderAt(source.root, headCommits.get(ref) ?? null)),
+      signals,
       worktrees,
       parsed: cache && { entries: cache.plans, used: new Set<string>() },
+      gate,
+      statuses: cache?.statuses,
+      now,
     },
     errors,
   }
@@ -535,29 +607,48 @@ const decoratedViews = (
     ),
   )
 
-/** 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 }))
+/** Each source with the tone and the label its config gives it. */
+const withSourceStyle = (
+  statuses: readonly SourceStatus[],
+  { herdSources, sourceLabels }: Pick<PlansSettings, 'herdSources' | 'sourceLabels'>,
+): HerdSource[] =>
+  statuses.map((status) => {
+    const label = sourceLabels[status.name]
+    const tone = herdSources.find(({ name }) => name === status.name)?.tone ?? null
+    return { ...status, tone, ...(label === undefined ? {} : { label }) }
+  })
 
-const plannedOf = (
+/**
+ * The open phases no lane with an agent leads, a plan marked stale by its last change at `baseCommit`; none while the
+ * view shows one lane.
+ */
+const plannedOf = async (
   source: Source,
-  plans: Record<string, string>,
   results: readonly LaneResult[],
-  sprintDirectory: string,
-  now: number,
-): PlannedPlan[] =>
-  source.options.lane
-    ? []
-    : 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,
-      )
+  context: {
+    plans: Record<string, string>
+    sprintDirectory: string
+    now: number
+    parsed: PlanSources['parsed']
+    baseCommit: string | null
+  },
+): Promise<PlannedPlan[]> => {
+  if (source.options.lane) return []
+  const { plans, sprintDirectory, now, parsed, baseCommit } = context
+  const planned = plannedPlans({
+    plans,
+    lanes: results.map(({ view }) => ({ lane: view.progress.lane, agent: view.status.agent })),
+    sprintDirectory,
+    language: source.settings.planLanguage,
+    parse: (markdown, path) => parsedPlanPhases(parsed, path, markdown, source.settings.planLanguage),
+  })
+  const touchedAt = await lastChangesAt(
+    source.root,
+    baseCommit,
+    planned.map(({ path }) => path),
+  )
+  return markStale(planned, touchedAt, now)
+}
 
 /**
  * Reads the board, its plans and the lanes' state. `memories` holds, per lane, what the herd saw at the last read; it
@@ -571,25 +662,27 @@ export const loadSnapshot = async (
   cache?: ReadCache,
 ): Promise<Snapshot> => {
   const { root, sprintFile, options, settings } = source
+  const gate = createSliceGate(SLICE_MS)
   const fallbacks: Fallbacks = []
   const baseRef = baseRefOf(settings)
-  const base = baseReaderOf(root, baseRef)
+  const baseCommit = await resolveCommit(root, baseRef)
+  const base = baseReaderAt(root, baseCommit)
   const boardPath = boardRepoPathOf(root, settings, sprintFile)
-  const board = await readBoardLanes(source, base, boardPath, fallbacks)
+  const board = await readBoardLanes(source, base, boardPath, fallbacks, cache?.boardRows ?? boardRowsOf)
   const { markdown } = board
   const sprintDirectory = dirname(boardPath)
   const worktrees = join(root, settings.worktreeDirectory)
   const now = Date.now()
   const liveBoard = board.liveMarkdown
-  const laneSet = laneSetOf(source, { base, board, sprintDirectory, worktrees, cache }, pullRequests, now)
+  const laneSet = await laneSetOf(source, { base, board, sprintDirectory, worktrees, cache, gate }, 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, herdSources } = settings
   const watched =
     ticketSources.length > 0 || herdSources.length > 0 || results.some(({ view }) => view.pullRequests.length > 0)
+  await gate.pass()
   const reading = watched
     ? readWatchReading(
         root,
@@ -600,6 +693,7 @@ export const loadSnapshot = async (
         herdSources.map(({ name }) => name),
       )
     : null
+  await gate.pass()
   const waitingRecords = readWaitingRecords(root)
   const waiting = withSourcePrefix(
     waitingItemsOf(liveBoard, settings.planLanguage, waitingRecords, now),
@@ -609,23 +703,35 @@ export const loadSnapshot = async (
   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
+  await gate.pass()
+  const views = decoratedViews(results, {
+    reading,
+    phaseModels: readPhaseModels(root),
+    sprintDirectory,
+    sentChips,
+    restNoteOf: (lane) =>
+      restNote(readLaneReport(laneReportPath(worktreeOf(root, settings, lane), lane))?.text ?? null),
+  })
+  await gate.pass()
+  const planned = await plannedOf(source, results, {
+    plans: documentsPlans,
+    sprintDirectory,
+    now,
+    parsed,
+    baseCommit,
+  })
+  if (parsed) dropUnused(parsed.entries, parsed.used)
+  await gate.pass()
   return {
     title: unknownLaneTitle ?? sprintTitleOf(markdown, sprintDirectory),
-    views: decoratedViews(results, {
-      reading,
-      phaseModels: readPhaseModels(root),
-      sprintDirectory,
-      sentChips,
-      restNoteOf: (lane) =>
-        restNote(readLaneReport(laneReportPath(worktreeOf(root, settings, lane), lane))?.text ?? null),
-    }),
+    views,
     documents: {
       sprint: markdown,
       plans: documentsPlans,
       laneOrder: [...laneSet.lanes, ...laneSet.unlisted].map((lane) => lane.name),
       lanes: board.lanes,
     },
-    planned: plannedOf(source, documentsPlans, results, sprintDirectory, now),
+    planned,
     files: [sprintFile, ...results.flatMap((result) => result.files)],
     titles: new Map(
       results.flatMap(({ view, pane }) =>
@@ -636,13 +742,8 @@ export const loadSnapshot = async (
     watch: reading?.health,
     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 } } : {}),
+    yourTurn: yourTurnOfBoard(liveBoard, settings.planLanguage, waiting, now),
+    ...(reading?.sources ? { sourceBlock: { sources: withSourceStyle(reading.sources, settings), now } } : {}),
     tones: settings.tones,
     unplaced: unplacedOf(laneSet.sources, laneSet.lanes, Boolean(options.lane)),
     ...(ticketSources.length > 0 ? { watchesTickets: true } : {}),

package/src/plans/source-asked.ts

@@ -1,6 +1,6 @@
 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. */
+/** Whether the source `source` has an entry titled `title` that an open row of "Your turn" asks about. */
 export type AskedCheck = (source: string, title: string) => boolean
 
 const same = (left: string, right: string): boolean => left.trim().toLowerCase() === right.trim().toLowerCase()

package/src/plans/source-rows.ts

@@ -7,15 +7,24 @@ import type { AskedCheck } from './source-asked'
 import { chevronOf } from './symbols'
 import type { BlockItem } from './waiting-click'
 
-/** A source's status with the tone its config names for the mark while its report is new; null where it names none. */
-export type HerdSource = SourceStatus & { tone?: ToneName | null }
+/**
+ * A source's status with the tone its config names for the mark while its report is new (null where it names none) and
+ * the label its config gives it, absent where it gives none.
+ */
+export type HerdSource = SourceStatus & { tone?: ToneName | null; label?: string }
+
+/** One source in the line of the folded sources block: what it says and the tone it wears, none for dim. */
+export type SourceSummary = { text: string; tone?: ToneName }
 
 /** The sources block: the listed sources, and the clock (epoch milliseconds) their ages are counted against. */
 export type SourceBlock = { sources: HerdSource[]; now: number }
 
-/** What decides how the rows of the block look: the keys the user opened, and which entries a row of "Waiting for you" asks about. */
+/** What decides how the rows of the block look: the keys the user opened, and which entries a row of "Your turn" asks about. */
 export type SourceView = { expanded: ReadonlySet<string>; asked: AskedCheck }
 
+/** The widths of the count column and the time column over the entries shown; the count column is 0 without counts. */
+type EntryColumns = { count: number; time: number }
+
 /** How many entries of an opened source show before `+<n> more`. */
 export const SOURCE_ENTRY_ROWS = 5
 
@@ -23,7 +32,7 @@ const SOURCE_MARK = '●'
 const ENTRY_MARK = '•'
 const MORE_MARK = ' '
 const SEPARATOR = ' · '
-const ASKED_TEXT = '↑ asked'
+const ASKED_TEXT = '↑ in your turn'
 const MINUTE_MS = 60_000
 const HOUR_MS = 60 * MINUTE_MS
 const DAY_MS = 24 * HOUR_MS
@@ -114,10 +123,18 @@ const entryToneOf = (
   return entry.isNew ? (source.tone ?? newTone) : undefined
 }
 
-const entryTextOf = (entry: EntryStatus, now: number, isAsked: boolean): string =>
-  [entry.count === null ? '' : `${entry.count}×`, clockOf(entry.at, now), isAsked ? ASKED_TEXT : '']
-    .filter((part) => part !== '')
-    .join(' ')
+const countOf = ({ count }: EntryStatus): string => (count === null ? '' : `${count}×`)
+
+const columnsOf = (entries: readonly EntryStatus[], now: number): EntryColumns => ({
+  count: Math.max(0, ...entries.map((entry) => textWidth(countOf(entry)))),
+  time: Math.max(0, ...entries.map(({ at }) => textWidth(clockOf(at, now)))),
+})
+
+/** `113× 11:11` with both columns padded, so the titles behind it start in one column whatever their width. */
+const entryLeadOf = (entry: EntryStatus, now: number, columns: EntryColumns): string => {
+  const time = padVisible(clockOf(entry.at, now), columns.time)
+  return columns.count === 0 ? time : `${padVisible(countOf(entry), columns.count)} ${time}`
+}
 
 const entryItem = (
   source: HerdSource,
@@ -125,17 +142,18 @@ const entryItem = (
   view: SourceView,
   now: number,
   newTone: ToneName,
-  titleWidth: number,
+  columns: EntryColumns,
 ): BlockItem => {
   const isAsked = view.asked(source.name, entry.title)
   const tone = entryToneOf(isAsked, entry, source, newTone)
   return {
     key: entryKey(source.name, entry),
     mark: ENTRY_MARK,
-    lead: padVisible(entry.title, titleWidth),
-    text: entryTextOf(entry, now, isAsked),
+    lead: entryLeadOf(entry, now, columns),
+    text: isAsked ? `${ASKED_TEXT} ${entry.title}` : entry.title,
     url: entry.url,
     ask: { kind: ASK_KIND.sourceEntry, source: source.name, title: entry.title },
+    expands: false,
     ...(tone && { tone }),
     ...(isAsked && { dim: true }),
   }
@@ -153,10 +171,10 @@ const moreItem = (name: string, hidden: number, showsAll: boolean): BlockItem =>
 const entryItems = (source: HerdSource, view: SourceView, now: number, newTone: ToneName): BlockItem[] => {
   const showsAll = view.expanded.has(sourceMoreKey(source.name))
   const shown = showsAll ? source.entries : source.entries.slice(0, SOURCE_ENTRY_ROWS)
-  const titleWidth = Math.max(0, ...shown.map(({ title }) => textWidth(title)))
+  const columns = columnsOf(shown, now)
   const hidden = source.entries.length - SOURCE_ENTRY_ROWS
   return [
-    ...shown.map((entry) => entryItem(source, entry, view, now, newTone, titleWidth)),
+    ...shown.map((entry) => entryItem(source, entry, view, now, newTone, columns)),
     ...(hidden > 0 ? [moreItem(source.name, hidden, showsAll)] : []),
   ]
 }
@@ -166,9 +184,10 @@ const DEFAULT_VIEW: SourceView = { expanded: new Set(), asked: () => false }
 /**
  * The rows of the sources block: per source one row with its name, when it ran, since when it fails and, for a source
  * without entries, its newest report. A source with entries is folded to that row, and a click on it opens its entries
- * (`view.expanded` holds its key): each with title, count and time, at most five and then `+<n> more`, a click on an
- * entry opens its address, `[ask]` asks the coordinator to look at exactly that entry. An entry that a row of
- * "Waiting for you" already asks about is dim and says `↑ asked`, and it does not make the source amber.
+ * (`view.expanded` holds its key): each with count and time as a fixed column, then its title, cut at the pane's edge,
+ * at most five and then `+<n> more`. An entry never expands: a click opens its address, `[ask]` asks the coordinator
+ * to look at exactly that entry. An entry that a row of "Your turn" already asks about is dim and starts with
+ * `↑ in your turn`, and it does not make the source amber.
  * `newTone` is the tone of the role `new`, which a source without its own tone wears while it has something new.
  */
 export const sourceItems = (
@@ -184,5 +203,28 @@ export const sourceItems = (
   ])
 }
 
-/** The keys of all rows: what the fold of the block remembers. */
-export const sourceKeys = (sources: readonly SourceStatus[]): string[] => sources.map(sourceKey)
+const entriesText = (count: number): string => `${count} ${count === 1 ? 'entry' : 'entries'}`
+
+const summaryTextOf = (source: HerdSource, now: number, asked: AskedCheck): string => {
+  const name = source.label ?? source.name
+  if (source.failingSince !== null) return `${name} failing since ${agoOf(source.failingSince, now)}`
+  if (source.entries.length === 0) return `${name} ${source.ranAt === null ? 'not run yet' : agoOf(source.ranAt, now)}`
+  const fresh = source.entries.filter((entry) => isUnaskedNew(source.name, entry, asked)).length
+  return `${name} ${entriesText(source.entries.length)}${fresh > 0 ? `, ${fresh} new` : ''}`
+}
+
+/**
+ * What the folded sources block says of each source, `errors 5 entries, 1 new`, `uptime 7 h ago`: its label, then
+ * its entries and how many are new and not yet in "Your turn", or when it ran, or since when it fails. A source wears
+ * the tone of its mark (red while failing, its own or `newTone` with a new entry not in "Your turn"), else none.
+ */
+export const sourceSummaries = (
+  sources: readonly HerdSource[],
+  now: number,
+  newTone: ToneName,
+  asked: AskedCheck,
+): SourceSummary[] =>
+  sources.map((source) => {
+    const tone = toneOf(source, newTone, asked)
+    return { text: summaryTextOf(source, now, asked), ...(tone && { tone }) }
+  })

package/src/plans/sprint-html.ts

@@ -236,7 +236,7 @@ const plannedRow = ({ title, plan, phaseIds, done, total }: PagePlanned): string
 const plannedSection = ({ planned }: SprintPage): string => {
   if (planned.length === 0) return ''
   const phases = plannedPhaseCount(planned)
-  const summary = `<summary>○ ${escapeHtml(TEXTS.planned(phases, planned.length))}</summary>`
+  const summary = `<summary>○ ${escapeHtml(TEXTS.backlog(phases, planned.length))}</summary>`
   return `<details class="planned">${summary}<ul class="phases">${planned.map(plannedRow).join('')}</ul></details>`
 }