jackherd 1.6.0 → 1.7.0

package/src/watch/command.ts

@@ -17,8 +17,8 @@
  * under Claude Code's Monitor tool, which turns every line into a message. Without lane names it watches every
  * worktree whose name a herdr agent carries or the board's lanes table lists, and prints `lane added: <name>` /
  * `lane removed: <name>` as that set changes. With every GitHub read it fetches `origin/<baseBranch>` once the
- * remote moved past it, so the plans view, which watches `FETCH_HEAD`, shows a merged lane row at once. Inside herdr
- * it brings back missing plans views of the board's lanes like `jh plans --ensure`: at its start, for every
+ * remote moved past it, so the herd, which watches `FETCH_HEAD`, shows a merged lane row at once. Inside herdr
+ * it brings back missing herd panes of the board's lanes like `jh herd --ensure`: at its start, for every
  * added lane and for every lane whose agent appeared.
  *
  * `watch source <name> --dry-run` runs one source once instead and prints what it would report (`source-dry-run-command.ts`).
@@ -35,7 +35,7 @@ import { defaultCoordinatorName } from '../context/coordinator-name'
 import { coordinatorSettings } from '../context/options'
 import { contextReport } from '../context/report'
 import { agentLog } from '../context/session-log'
-import { type LaneProgress, parseSprintLanes } from '../plan-format'
+import { type LaneProgress, parseSprintLanes, type SprintLane } from '../plan-format'
 import { terminalSafe } from '../plan-format/terminal-text'
 import { boardFor, foundLanesOf } from '../plans/board-pick'
 import { ensurePlanPanes } from '../plans/ensure-panes'
@@ -48,6 +48,7 @@ import { defaultUpdateCheck } from '../sync/if-changed'
 import { herdrLaneStatusSource } from '../terminal/herdr'
 import { AGENT_STATUS } from '../terminal/types'
 import { startedKit } from '../version/started-kit'
+import { type ApprovalRequestFile, approvalEvents, readApprovalRequests, recordApprovals } from './approvals'
 import {
   type CoordinatorRead,
   contextReadingOf,
@@ -57,16 +58,18 @@ import {
   explainedRead,
   readingOf,
 } from './coordinator-fill'
+import { readFailedTests } from './failure-read'
+import { type FailureReading, failureReadingOf, failureTargets, recordFailures } from './failures'
 import {
-  type FeedbackItem,
   type FeedbackRead,
   type FeedbackTarget,
   feedbackEvents,
+  feedbackFilterOf,
   feedbackReadOf,
   feedbackSince,
   feedbackTargets,
-  recordFeedback,
 } from './feedback'
+import { type FeedbackItem } from './feedback-item'
 import { type FeedbackItemsRead, readCommentItems, readFeedbackItems, readOwnLogin } from './feedback-read'
 import { answered, deployTargetOf, type GithubRead, readGithub, targetText } from './github-read'
 import { currentPhaseCountsOf, type PhaseCount, progressNotes } from './heartbeat-progress'
@@ -74,8 +77,11 @@ import { agentScreen, listAgents } from './herdr'
 import { endedByKitUpdate } from './kit-update'
 import { type LaneReadings, laneFillEvents, recordLaneLevels } from './lane-fill'
 import { laneMessage, rememberedStatusLines, statusBlock } from './lane-message'
-import { boardCheckoutRows, watchedLaneProgress } from './lane-progress'
+import { type LaneModelReading, laneModelEvents, recordLaneModels } from './lane-model'
+import { laneParallelEvents, recordLaneParallels } from './lane-parallel'
+import { boardCheckoutRows, watchedLaneParallel, watchedLaneProgress } from './lane-progress'
 import {
+  approvalDutyLines,
   armLine,
   blockedDutyLines,
   coordinatorStatusLine,
@@ -83,9 +89,11 @@ import {
   ghUnavailableStatusLine,
   type LaneReport,
   laneFillDutyLines,
+  laneModelDutyLines,
   laneReportLine,
   mergeDutyLines,
   otherPullRequestsLine,
+  parallelDutyLines,
   sourceEventLines,
   sourceFailingStatusLine,
   watchEventLine,
@@ -117,27 +125,20 @@ import {
 import { readDeploymentCandidates } from './preview-read'
 import {
   commentCandidates,
-  feedbackFilterOf,
   feedbackReadCovers,
   type PreviewRead,
   previewEvents,
   previewReadOf,
-  recordPreviews,
   unreportedTargets,
 } from './previews'
 import { latestPullRequestOf, type WatchedPullRequest } from './pull-requests'
+import { recordedReadsOf } from './recorded-reads'
 import { withSingleReportNotice } from './single-report'
 import { readOrchestrateSkill, skillLineFor } from './skill-change'
 import { sourceDryRun } from './source-dry-run-command'
 import { runSource, SOURCE_LIMITS } from './source-run'
-import {
-  isSourceDue,
-  recordSources,
-  type SourceRun,
-  type SourceSettings,
-  type SourceState,
-  sourceEvents,
-} from './sources'
+import { recordWatchedSources } from './source-tickets'
+import { isSourceDue, type SourceRun, type SourceSettings, type SourceState, sourceEvents } from './sources'
 import { streamHeartbeatLine } from './stream-output'
 import { WATCH_TEXTS, type WatchTexts } from './texts'
 import { updateAnnouncer } from './update-available'
@@ -174,6 +175,8 @@ type Files = { state: string; lock: string }
 /** The logins whose feedback does not count, or false when the project turned feedback off. */
 type FeedbackConfig = JackherdConfig['watch']['feedback']
 
+type ChecksConfig = JackherdConfig['watch']['checks']
+
 /** Where deploy previews are read from; undefined when the project reads none. */
 type PreviewsConfig = JackherdConfig['watch']['previews']
 
@@ -191,10 +194,11 @@ type Watch = {
   settings: PlansSettings
   deploy: DeployConfig | undefined
   feedback: FeedbackConfig
+  checks: ChecksConfig
   previews: PreviewsConfig
   sources: SourceSettings[]
   texts: WatchTexts
-  /** Runs inside herdr with the herdr adapter, so missing plans views can be brought back. */
+  /** Runs inside herdr with the herdr adapter, so missing herd panes can be brought back. */
   herdr: boolean
 }
 
@@ -234,6 +238,8 @@ type Watching = {
   ownLogin: string | null
   /** The last feedback read that answered; its targets and items are recorded with every state. */
   feedbackRead: FeedbackRead | null
+  /** The logs of the red pull requests read at the last GitHub poll; recorded with every state like the feedback read. */
+  failureReadings: FailureReading[]
   /** The last preview read that answered; recorded with every state like the feedback read. */
   previewRead: PreviewRead | null
   /** The runs of the sources due at the last GitHub poll; recorded with every state like the feedback read. */
@@ -242,6 +248,12 @@ type Watching = {
   sourceRanAt: Record<string, number>
   /** The lanes' fills of the last read; a lane without an entry or with null has no value. */
   laneReadings: LaneReadings
+  /** The lanes' models against their board rows at the last read; recorded with every state like the fills. */
+  laneModelReadings: Record<string, LaneModelReading>
+  /** The phases of each lane's plan that can run together at the last read; recorded with every state like the models. */
+  laneParallelReadings: Record<string, string[]>
+  /** The approval requests of the last poll; null before the first read, so the stored ids stay. */
+  approvalRequests: ApprovalRequestFile[] | null
   planViews: PlanViews
 }
 
@@ -267,24 +279,30 @@ const recordedOf = (watch: Watch, watching: Watching): WatchState => {
     recordWatchState(watching.state, observationOf(watching), watching.githubReadAt),
     readingOf(watching.coordinator.read),
   )
-  const read = watching.feedbackRead
-  const withFeedback = read ? { ...recorded, feedback: recordFeedback(recorded.feedback, read) } : recorded
-  const previews = watching.previewRead
-  const withPreviews = previews
-    ? { ...withFeedback, previews: recordPreviews(withFeedback.previews, previews) }
-    : withFeedback
+  const withReads = recordedReadsOf(recorded, {
+    feedback: watching.feedbackRead,
+    previews: watching.previewRead,
+    pullRequests: answered(watching.github)?.pullRequests ?? null,
+    failures: watching.failureReadings,
+  })
   const withLevels = {
-    ...withPreviews,
-    laneLevels: recordLaneLevels(withPreviews.laneLevels, watching.laneReadings, watching.lanes),
-    sources: recordSources(withPreviews.sources, watching.sourceRuns, sourceNamesOf(watch), watching.githubReadAt),
+    ...withReads,
+    laneLevels: recordLaneLevels(withReads.laneLevels, watching.laneReadings, watching.lanes),
+    laneModels: recordLaneModels(withReads.laneModels, watching.laneModelReadings, watching.lanes),
+    laneParallels: recordLaneParallels(withReads.laneParallels, watching.laneParallelReadings, watching.lanes),
+    approvals: watching.approvalRequests ? recordApprovals(watching.approvalRequests) : withReads.approvals,
+    sources: recordWatchedSources(withReads.sources, watching.sourceRuns, watch.sources, watching.githubReadAt),
   }
   return withReportBaselines(withLevels, watching.lanes, (lane) => reportMtime(reportPathOf(watch, lane)))
 }
 
-const sourceNamesOf = (watch: Watch): string[] => watch.sources.map(({ name }) => name)
-
 /** The events of one GitHub read against the state it is compared with. */
-const githubEventsOf = (state: WatchState, github: GithubRead, laneBranches: Record<string, string>): WatchEvent[] => {
+const githubEventsOf = (
+  state: WatchState,
+  github: GithubRead,
+  laneBranches: Record<string, string>,
+  readings: readonly FailureReading[],
+): WatchEvent[] => {
   if (!github.ok) {
     const outage = ghOutageEvent(state, github.error)
     return outage ? [outage] : []
@@ -292,8 +310,9 @@ const githubEventsOf = (state: WatchState, github: GithubRead, laneBranches: Rec
   const branches = { ...state.laneBranches, ...laneBranches }
   const merges = mergeCommitsOf(github.pullRequests, branches)
   const ownMerges = ownMergeCommitsOf(state, github.pullRequests, branches)
+  const failures = recordFailures(state.failures, github.pullRequests, readings)
   return [
-    ...pullRequestEvents(state, github.pullRequests, branches),
+    ...pullRequestEvents(state, github.pullRequests, branches, failures),
     ...deployEvents(state, github.runs, merges, ownMerges),
   ]
 }
@@ -324,13 +343,16 @@ const coordinatorNameFor = (watch: Watch, agents: readonly HerdrAgent[]): string
   coordinatorNameOf(agents, process.env.HERDR_PANE_ID) ??
   defaultCoordinatorName(basename(watch.root))
 
-/** One read of the fills: the coordinator's, and each watched lane's (null without a value). */
-type FillRead = { coordinator: CoordinatorRead; lanes: LaneReadings }
+/**
+ * One read of the fills: the coordinator's, and each watched lane's (null without a value), with `models`, lane → the
+ * model of its agent's last answer (null without one), read from the same report.
+ */
+type FillRead = { coordinator: CoordinatorRead; lanes: LaneReadings; models: Record<string, string | null> }
 
 /**
  * The coordinator's fill with its own thresholds, as `jh context <name> --coordinator` computes it, or why there
- * is none, and each lane's fill with the lanes' thresholds, as the plans view shows it: from one herdr listing. When
- * herdr cannot be asked, the lanes have no reading, so their stored levels stay.
+ * is none, and each lane's fill with the lanes' thresholds, as the herd shows it: from one herdr listing. When
+ * herdr cannot be asked, the lanes have no reading, so their stored levels stay. Each lane's report also gives its model.
  */
 const fillReadFor = (watch: Watch, name: string, agents: readonly HerdrAgent[], lanes: readonly string[]): FillRead => {
   const target = coordinatorTargetOf(agents, name, process.env.HERDR_PANE_ID)
@@ -339,14 +361,14 @@ const fillReadFor = (watch: Watch, name: string, agents: readonly HerdrAgent[],
       target.kind === 'unnamedPane' ? { pane: target.pane, name } : undefined,
     )
     const own = contextReport(listed, name, agentLog, coordinatorSettings(watch.settings.context))
-    const laneReading = (lane: string) =>
-      contextReadingOf(contextReport(listed, lane, agentLog, watch.settings.context))
+    const reports = lanes.map((lane) => [lane, contextReport(listed, lane, agentLog, watch.settings.context)] as const)
     return {
       coordinator: explainedRead(coordinatorReadOf(own), target, name, watch.texts),
-      lanes: Object.fromEntries(lanes.map((lane) => [lane, laneReading(lane)])),
+      lanes: Object.fromEntries(reports.map(([lane, report]) => [lane, contextReadingOf(report)])),
+      models: Object.fromEntries(reports.map(([lane, report]) => [lane, report?.model ?? null])),
     }
   } catch (error) {
-    return { coordinator: { reason: errorText(error) }, lanes: {} }
+    return { coordinator: { reason: errorText(error) }, lanes: {}, models: {} }
   }
 }
 
@@ -515,6 +537,9 @@ const reportOf = async (
     ...blockedDutyLines(stopped, watching.current, watch.texts),
     ...mergeDutyLines(events, watching.lanes, watch.texts),
     ...laneFillDutyLines(events, watch.texts),
+    ...laneModelDutyLines(events, watch.texts),
+    ...parallelDutyLines(events, watch.texts),
+    ...approvalDutyLines(events, watch.texts),
   ]
   const status = await statusLinesOf(watch, watching, next)
   const block = statusBlock(status.laneLines, status.coordinator, next.statusLines, status.others)
@@ -533,11 +558,33 @@ const recordGithub = (
   github: GithubRead,
   laneBranches: Record<string, string>,
   now: number,
+  readings: FailureReading[],
 ): WatchEvent[] => {
   watching.github = github
   watching.laneBranches = laneBranches
   watching.githubReadAt = now
-  return githubEventsOf(watching.state, watching.github, watching.laneBranches)
+  watching.failureReadings = readings
+  return githubEventsOf(watching.state, watching.github, watching.laneBranches, readings)
+}
+
+/**
+ * The logs of the lanes' red pull requests, once per head commit (`failureTargets`): `gh run view --log-failed` of each
+ * failed run, matched with `watch.checks.failedTestPattern`, which holds with feedback off too. A read
+ * that fails is recorded as not read, so the next GitHub poll asks again, a few times at most.
+ */
+const readFailures = async (
+  watch: Watch,
+  watching: Watching,
+  github: GithubRead,
+  branches: Record<string, string>,
+): Promise<FailureReading[]> => {
+  const answer = answered(github)
+  if (!answer) return []
+  const pattern = watch.checks.failedTestPattern
+  const targets = failureTargets(watching.state.failures, answer.pullRequests, branches)
+  return Promise.all(
+    targets.map(async (target) => failureReadingOf(target, await readFailedTests(watch.root, target.runIds, pattern))),
+  )
 }
 
 const recordCoordinator = (watching: Watching, coordinator: Coordinator): WatchEvent[] => {
@@ -551,6 +598,49 @@ const recordLaneFills = (watching: Watching, readings: LaneReadings): WatchEvent
   return laneFillEvents(watching.state.laneLevels, readings)
 }
 
+/** Lane → the model column of its newest board row; none when the board cannot be read, so no lane reports. */
+const laneModelColumns = (watch: Watch): Record<string, string> =>
+  Object.fromEntries(
+    (readSprintLanes(watch) ?? []).flatMap((lane) => lane.steps.slice(-1).map((step) => [lane.name, step.model])),
+  )
+
+/** The agent states a lane can be switched in: it ended its turn and waits for no answer. */
+const IDLE_STATUSES: ReadonlySet<string> = new Set([AGENT_STATUS.done, AGENT_STATUS.idle])
+
+/** Each lane's model against its column, as far as both are known, with whether its agent is idle. */
+const laneModelReadingsOf = (
+  watch: Watch,
+  watching: Watching,
+  models: Record<string, string | null>,
+): Record<string, LaneModelReading> => {
+  const columns = laneModelColumns(watch)
+  return Object.fromEntries(
+    Object.entries(models).flatMap(([lane, model]) => {
+      const column = columns[lane]
+      const idle = IDLE_STATUSES.has(watching.current[lane]?.status ?? '')
+      return column === undefined ? [] : [[lane, { model, idle, column }]]
+    }),
+  )
+}
+
+const recordLaneModelReads = (watching: Watching, readings: Record<string, LaneModelReading>): WatchEvent[] => {
+  watching.laneModelReadings = readings
+  return laneModelEvents(watching.state.laneModels, readings)
+}
+
+/** Each open lane's phases that can run together, read from the plan of its newest row; none when the board cannot be read. */
+const laneParallelReadingsOf = (watch: Watch, watching: Watching): Record<string, string[]> =>
+  Object.fromEntries(
+    (readSprintLanes(watch) ?? [])
+      .filter((lane) => !lane.closed && watching.lanes.includes(lane.name))
+      .map((lane) => [lane.name, watchedLaneParallel(watch.root, watch.settings, watch.sprintFile, lane)]),
+  )
+
+const recordLaneParallelReads = (watching: Watching, readings: Record<string, string[]>): WatchEvent[] => {
+  watching.laneParallelReadings = readings
+  return laneParallelEvents(watching.state.laneParallels, readings)
+}
+
 /** The account `gh` runs as, read once and kept; null while `gh` cannot tell. */
 const ensureOwnLogin = async (watch: Watch, watching: Watching): Promise<string | null> => {
   watching.ownLogin ??= await readOwnLogin(watch.root)
@@ -573,7 +663,7 @@ const readFeedback = async (
   if (own === null) return null
   const items = await readFeedbackItems(watch.root, targets, feedbackSince(watching.state.feedback, now))
   if (!items.ok) return null
-  const filter = feedbackFilterOf(own, watch.feedback.ignore, watch.previews)
+  const filter = feedbackFilterOf(own, watch.feedback, watch.previews?.authors ?? [])
   return { read: feedbackReadOf(now, targets, items.items, filter), items: items.items }
 }
 
@@ -669,30 +759,35 @@ const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: n
   ])
   const pullRequests = answered(github)?.pullRequests ?? null
   const branches = { ...watching.state.laneBranches, ...laneBranches }
+  const failureReadings = await readFailures(watch, watching, github, branches)
   const targets = feedbackTargets(pullRequests, branches, watching.state.feedback)
   const feedback = await readFeedback(watch, watching, targets, now)
   const previews = pullRequests ? await readPreviews(watch, watching, targets, feedback?.items ?? null, now) : null
   return [
-    ...recordGithub(watching, github, laneBranches, now),
+    ...recordGithub(watching, github, laneBranches, now, failureReadings),
     ...recordFeedbackRead(watching, feedback?.read ?? null),
     ...recordPreviewRead(watching, previews),
     ...recordSourceRuns(watch, watching, sourceRuns),
     ...recordCoordinator(watching, { name, read: fills.coordinator }),
     ...recordLaneFills(watching, fills.lanes),
+    ...recordLaneModelReads(watching, laneModelReadingsOf(watch, watching, fills.models)),
+    ...recordLaneParallelReads(watching, laneParallelReadingsOf(watch, watching)),
   ]
 }
 
-/** The sprint's lane names; the previous ones when the sprint cannot be read, so no lane drops out over it. */
-const sprintLaneNames = (watch: Watch, previous: string[]): string[] => {
+/** The board's lanes, null when the board cannot be read. */
+const readSprintLanes = (watch: Watch): SprintLane[] | null => {
   try {
-    return parseSprintLanes(readFileSync(watch.sprintFile, 'utf8'), watch.settings.planLanguage).map(
-      (lane) => lane.name,
-    )
+    return parseSprintLanes(readFileSync(watch.sprintFile, 'utf8'), watch.settings.planLanguage)
   } catch {
-    return previous
+    return null
   }
 }
 
+/** The sprint's lane names; the previous ones when the sprint cannot be read, so no lane drops out over it. */
+const sprintLaneNames = (watch: Watch, previous: string[]): string[] =>
+  readSprintLanes(watch)?.map((lane) => lane.name) ?? previous
+
 const lanesFor = (watch: Watch, agents: readonly HerdrAgent[], sprintLanes: readonly string[]): string[] =>
   watch.options.lanes ??
   discoverLanes({
@@ -701,7 +796,7 @@ const lanesFor = (watch: Watch, agents: readonly HerdrAgent[], sprintLanes: read
     sprintLanes,
   })
 
-/** Brings back missing plans views beside the coordinator and the board's lanes when `trigger` calls for it; only inside herdr. */
+/** Brings back missing herd panes beside the coordinator and the board's lanes when `trigger` calls for it; only inside herdr. */
 const keepViews = (watch: Watch, watching: Watching, trigger: EnsureTrigger) => {
   if (!watch.herdr) return
   watching.planViews = keepPlanViews(trigger, watching.planViews, {
@@ -738,7 +833,7 @@ const readAgents = (watching: Watching): boolean => {
   }
 }
 
-/** One herdr poll: the agents, the lane set, and once per poll the plans views of added lanes and of new agents. */
+/** One herdr poll: the agents, the lane set, and once per poll the herd panes of added lanes and of new agents. */
 const pollLanes = (watch: Watch, watching: Watching) => {
   const previous = watching.current
   if (!readAgents(watching)) return
@@ -790,7 +885,11 @@ const pollOnce = async (watch: Watch, watching: Watching): Promise<boolean> => {
   const { stream, heartbeatMinutes } = watch.options
   const now = Date.now()
   const due = now - watching.githubReadAt >= GITHUB_POLL_MS
-  const polledEvents = due ? await pollGithubAndCoordinator(watch, watching, now) : []
+  const githubEvents = due ? await pollGithubAndCoordinator(watch, watching, now) : []
+  // read at every poll, not with GitHub: a lane waits for the answer only minutes; after the await, so a state saved
+  // during the GitHub read records no request as seen before it was reported
+  watching.approvalRequests = readApprovalRequests(watch.root)
+  const polledEvents = [...githubEvents, ...approvalEvents(watching.state.approvals, watching.approvalRequests, now)]
   const stopped = [...firedLanes(watching.baseline, watching.current, watching.lanes), ...watching.departed]
   watching.departed = []
   const heartbeat = isHeartbeatDue(watching.quietSince, now, heartbeatMinutes * MINUTE_MS)
@@ -835,10 +934,14 @@ const initialWatching = (
   fetchingBase: false,
   ownLogin: null,
   feedbackRead: null,
+  failureReadings: [],
   previewRead: null,
   sourceRuns: [],
   sourceRanAt: {},
   laneReadings: {},
+  laneModelReadings: {},
+  laneParallelReadings: {},
+  approvalRequests: null,
   planViews: { failureReported: false },
 })
 
@@ -901,6 +1004,7 @@ const watchOf = (options: WatchOptions): Watch => {
     settings,
     deploy: config.watch.deploy,
     feedback: config.watch.feedback,
+    checks: config.watch.checks,
     previews: config.watch.previews,
     sources: config.watch.sources,
     texts: WATCH_TEXTS[settings.responseLanguage],

package/src/watch/failed-tests.ts

@@ -0,0 +1,52 @@
+import { terminalSafe } from '../plan-format/terminal-text'
+
+/** The most failed tests kept for one head commit. */
+export const FAILED_TEST_LIMIT = 50
+
+/** The longest test name kept; a log line is third-party text. */
+const FAILED_TEST_NAME_LENGTH = 200
+
+/** Log lines longer than this are not matched against the pattern, which bounds its work. */
+const MAX_LINE_LENGTH = 2_000
+
+/** `<job>\t<step>\t<ISO timestamp> ` in front of every line of `gh run view --log-failed`. */
+const LOG_PREFIX = /^[^\t]*\t[^\t]*\t\d{4}-\d{2}-\d{2}T[\d:.]+Z /
+
+const nameOf = (text: string): string => terminalSafe(text).trim().slice(0, FAILED_TEST_NAME_LENGTH)
+
+/**
+ * `names` as the view and the report may show them: terminal-safe, cut to the name length, empty and repeated ones
+ * dropped, at most `FAILED_TEST_LIMIT`. For names read back from the state file, which is no more trusted than the log.
+ */
+export const sanitisedFailedTests = (names: readonly string[]): string[] =>
+  [...new Set(names.map(nameOf).filter((name) => name !== ''))].slice(0, FAILED_TEST_LIMIT)
+
+const compiled = (pattern: string): RegExp | null => {
+  try {
+    return new RegExp(pattern)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * The names of the failed tests in the log `gh run view <id> --log-failed` printed, in the order first seen. Each line
+ * loses its job, step and timestamp prefix, then `pattern` (a regular expression) is matched against it: the first
+ * group is the name, else the whole match. A test the log names twice (Bun lists it in the run and in the summary) is
+ * listed once. Names are made terminal-safe and cut; at most `FAILED_TEST_LIMIT` are kept. A pattern that is no
+ * regular expression finds nothing.
+ */
+export const extractFailedTests = (log: string, pattern: string): string[] => {
+  const expression = compiled(pattern)
+  if (!expression) return []
+  const names = new Set<string>()
+  for (const raw of log.split('\n')) {
+    if (names.size >= FAILED_TEST_LIMIT) break
+    const line = raw.replace(/\r$/, '').replace(LOG_PREFIX, '')
+    if (line.length > MAX_LINE_LENGTH) continue
+    const match = expression.exec(line)
+    const name = nameOf(match?.[1] ?? match?.[0] ?? '')
+    if (name !== '') names.add(name)
+  }
+  return [...names]
+}

package/src/watch/failure-read.ts

@@ -0,0 +1,56 @@
+import { extractFailedTests, FAILED_TEST_LIMIT } from './failed-tests'
+import { type GhAnswer, runGh } from './gh'
+import { isRecord } from './json-guards'
+
+/** How long `gh run view --log-failed` may take before the call is given up; a read that timed out is tried again. */
+export const LOG_TIMEOUT_MS = 30_000
+
+/** Of a longer log only this many characters from the end are kept; Bun repeats its failures in the summary there. */
+export const LOG_TAIL_CHARS = 2_000_000
+
+/** `running` is true when a run was still going, which is no failure of the read and is not counted as an attempt. */
+export type FailedTestsRead = { ok: true; tests: string[] } | { ok: false; running: boolean }
+
+type RunGh = (args: string[]) => Promise<GhAnswer>
+
+export const logArgs = (runId: number): string[] => ['run', 'view', String(runId), '--log-failed']
+
+export const statusArgs = (runId: number): string[] => ['run', 'view', String(runId), '--json', 'status,conclusion']
+
+const COMPLETED = 'completed'
+
+const isRunning = (answer: GhAnswer): boolean => {
+  if (!answer.ok) return false
+  try {
+    const value: unknown = JSON.parse(answer.stdout)
+    return isRecord(value) && typeof value.status === 'string' && value.status !== COMPLETED
+  } catch {
+    return false
+  }
+}
+
+/**
+ * The failed tests in the logs of `runIds` matched with `pattern`. Each run is first asked for its status
+ * (`gh run view --json status`, cheap): while any is not completed, `gh` cannot give its failed log, so the read
+ * fails with `running` and the log is not asked for. Then one `gh run view --log-failed` per run, in parallel; any
+ * call that fails makes the read fail. The default calls give up after `LOG_TIMEOUT_MS` and keep only the last
+ * `LOG_TAIL_CHARS` characters of a log as it streams in. The log is whatever the project's jobs print, never interpreted.
+ */
+export const readFailedTests = async (
+  root: string,
+  runIds: readonly number[],
+  pattern: string,
+  run: RunGh = (args) =>
+    runGh(args, root, {
+      timeoutMs: LOG_TIMEOUT_MS,
+      ...(args.includes('--log-failed') && { tailChars: LOG_TAIL_CHARS }),
+    }),
+): Promise<FailedTestsRead> => {
+  const statuses = await Promise.all(runIds.map((runId) => run(statusArgs(runId))))
+  if (statuses.some(isRunning)) return { ok: false, running: true }
+  const answers = await Promise.all(runIds.map((runId) => run(logArgs(runId))))
+  const logs = answers.flatMap((answer) => (answer.ok ? [answer.stdout] : []))
+  if (logs.length < answers.length) return { ok: false, running: false }
+  const tests = new Set(logs.flatMap((text) => extractFailedTests(text, pattern)))
+  return { ok: true, tests: [...tests].slice(0, FAILED_TEST_LIMIT) }
+}

package/src/watch/failures.ts

@@ -0,0 +1,107 @@
+import { CHECKS } from '../plans/pull-requests'
+import type { FailedTestsRead } from './failure-read'
+import { isRecord } from './json-guards'
+import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
+
+/**
+ * What the watcher read of a red pull request's logs: the tests that failed on `headCommit`. `read` is true once the
+ * logs answered (with no test among them, too), `attempts` counts the reads tried, so a run that was still going when
+ * it was asked is asked again, a few times, and no head commit is read more than once it has answered.
+ */
+export type FailureRecord = { headCommit: string; tests: string[]; read: boolean; attempts: number }
+
+/** Pull request number → what was read for it; kept for the open pull requests only. */
+export type FailureState = Record<string, FailureRecord>
+
+/** A red pull request of a lane whose logs are to be read: the runs of its failed checks, and the reads tried so far. */
+export type FailureTarget = { number: number; headCommit: string; runIds: number[]; attempts: number }
+
+/** The result of reading one target; `attempts` is the count including this read. */
+export type FailureReading = FailureRecord & { number: number }
+
+/** A read that failed for another reason than a run still going is tried again at the next GitHub read, this often at most. */
+export const FAILURE_READ_ATTEMPTS = 3
+
+/** The most runs read for one head commit. */
+export const FAILURE_RUN_LIMIT = 3
+
+export const emptyFailureState = (): FailureState => ({})
+
+const isFailureRecord = (value: unknown): boolean =>
+  isRecord(value) &&
+  typeof value.headCommit === 'string' &&
+  Array.isArray(value.tests) &&
+  value.tests.every((test) => typeof test === 'string') &&
+  typeof value.read === 'boolean' &&
+  typeof value.attempts === 'number'
+
+export const isFailureState = (value: unknown): value is FailureState =>
+  isRecord(value) && Object.values(value).every(isFailureRecord)
+
+const runIdsOf = (pullRequest: WatchedPullRequest): number[] => [
+  ...new Set(pullRequest.failedRuns.flatMap(({ runId }) => (runId === null ? [] : [runId]))),
+]
+
+const needsReading = (record: FailureRecord | undefined, headCommit: string): boolean =>
+  record?.headCommit !== headCommit || (!record.read && record.attempts < FAILURE_READ_ATTEMPTS)
+
+/**
+ * The pull requests whose logs to read now: open, red, on a lane's branch, with a run among their failed checks, and
+ * not read yet on this head commit. Other pull requests get the names of their checks and nothing more.
+ */
+export const failureTargets = (
+  previous: FailureState,
+  pullRequests: readonly WatchedPullRequest[],
+  laneBranches: Readonly<Record<string, string>>,
+): FailureTarget[] => {
+  const branches = new Set(Object.values(laneBranches))
+  return pullRequests.flatMap((pullRequest) => {
+    const record = previous[String(pullRequest.number)]
+    const runIds = runIdsOf(pullRequest).slice(0, FAILURE_RUN_LIMIT)
+    const due =
+      pullRequest.state === PULL_REQUEST_STATE.open &&
+      pullRequest.checks === CHECKS.failed &&
+      branches.has(pullRequest.branch) &&
+      runIds.length > 0 &&
+      needsReading(record, pullRequest.headCommit)
+    const known = record?.headCommit === pullRequest.headCommit ? record.attempts : 0
+    return due ? [{ number: pullRequest.number, headCommit: pullRequest.headCommit, runIds, attempts: known }] : []
+  })
+}
+
+/**
+ * The reading of `target` from what `readFailedTests` answered. A failed read counts as an attempt, except one that
+ * found the run still going: that is asked again at every GitHub read until it ends, and the cap is for real errors.
+ */
+export const failureReadingOf = (
+  { number, headCommit, attempts }: FailureTarget,
+  result: FailedTestsRead,
+): FailureReading =>
+  result.ok
+    ? { number, headCommit, tests: result.tests, read: true, attempts: attempts + 1 }
+    : { number, headCommit, tests: [], read: false, attempts: result.running ? attempts : attempts + 1 }
+
+/**
+ * The state after `readings`: the readings stored, and only the open pull requests of `pullRequests` kept. Without
+ * GitHub's list (`null`) nothing is forgotten. Recording a reading twice gives the same state.
+ */
+export const recordFailures = (
+  previous: FailureState,
+  pullRequests: readonly WatchedPullRequest[] | null,
+  readings: readonly FailureReading[],
+): FailureState => {
+  const open = pullRequests
+    ? new Set(pullRequests.filter(({ state }) => state === PULL_REQUEST_STATE.open).map(({ number }) => String(number)))
+    : null
+  const merged: FailureState = {
+    ...previous,
+    ...Object.fromEntries(readings.map(({ number, ...record }) => [String(number), record])),
+  }
+  return open ? Object.fromEntries(Object.entries(merged).filter(([number]) => open.has(number))) : merged
+}
+
+/** The failed tests read for `headCommit` of the pull request; none for any other head commit. */
+export const failedTestsOf = (state: FailureState, number: number, headCommit: string): string[] => {
+  const record = state[String(number)]
+  return record?.headCommit === headCommit ? record.tests : []
+}