jackherd 1.6.0 → 1.7.0

package/src/watch/feedback-item.ts

@@ -0,0 +1,21 @@
+/** The three forms feedback takes on a pull request: a review, an inline review comment, a pull request comment. */
+export const FEEDBACK_FORM = { review: 'review', inline: 'inline', comment: 'comment' } as const
+
+export type FeedbackForm = (typeof FEEDBACK_FORM)[keyof typeof FEEDBACK_FORM]
+
+/**
+ * One piece of feedback as the watcher reads it; `state` is a review's (`APPROVED`, …), null for a comment. A review's
+ * `updatedAt` is when it was submitted: GitHub reports no later edit of a review, so an edited review is not new.
+ */
+export type FeedbackItem = {
+  form: FeedbackForm
+  id: number
+  pullRequest: number
+  author: string
+  createdAt: string
+  updatedAt: string
+  state: string | null
+  path: string | null
+  line: number | null
+  body: string
+}

package/src/watch/feedback-read.ts

@@ -1,5 +1,6 @@
 import { errorText } from '../plans/error-text'
-import { FEEDBACK_FORM, type FeedbackItem, type FeedbackTarget, parseFeedbackLines } from './feedback'
+import { type FeedbackTarget, parseFeedbackLines } from './feedback'
+import { FEEDBACK_FORM, type FeedbackItem } from './feedback-item'
 import { type GhAnswer, runGh } from './gh'
 
 export type FeedbackItemsRead = { ok: true; items: FeedbackItem[] } | { ok: false; error: string }

package/src/watch/feedback.ts

@@ -1,30 +1,10 @@
+import { FEEDBACK_FORM, type FeedbackForm, type FeedbackItem } from './feedback-item'
 import { isRecord } from './json-guards'
+import { isNoFindingComment, ROUND_WINDOW_MS } from './no-finding'
 import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
 
-/** The three forms feedback takes on a pull request: a review, an inline review comment, a pull request comment. */
-export const FEEDBACK_FORM = { review: 'review', inline: 'inline', comment: 'comment' } as const
-
-export type FeedbackForm = (typeof FEEDBACK_FORM)[keyof typeof FEEDBACK_FORM]
-
 export const FEEDBACK_EVENT = 'feedback'
 
-/**
- * One piece of feedback as the watcher reads it; `state` is a review's (`APPROVED`, …), null for a comment. A review's
- * `updatedAt` is when it was submitted: GitHub reports no later edit of a review, so an edited review is not new.
- */
-export type FeedbackItem = {
-  form: FeedbackForm
-  id: number
-  pullRequest: number
-  author: string
-  createdAt: string
-  updatedAt: string
-  state: string | null
-  path: string | null
-  line: number | null
-  body: string
-}
-
 /** An open pull request of a lane whose feedback is read. */
 export type FeedbackTarget = { number: number; lane: string; headCommit: string }
 
@@ -53,8 +33,13 @@ export type FeedbackRead = {
   changesRequested: number[]
 }
 
-/** Whose feedback does not count: `own` is the account the lanes push with, `ignore` the project's list. */
-export type FeedbackFilter = { own: string; ignore: readonly string[] }
+/**
+ * What does not count as feedback: `own` is the account the lanes push with, `ignore` the project's list of authors,
+ * `noFindingTemplates` the texts of a bot's comment that reports no finding (`isNoFindingComment`); none when left out.
+ */
+export type FeedbackFilter = { own: string; ignore: readonly string[]; noFindingTemplates: readonly string[] }
+
+type FeedbackConfig = { ignore: readonly string[]; noFindingTemplates: readonly string[] }
 
 /** `place` is `<path>:<line>` for an inline comment, else null; `text` the first line of the body. */
 export type FeedbackEntry = { place: string | null; text: string }
@@ -69,8 +54,11 @@ export type FeedbackEvent = {
   entries: FeedbackEntry[]
 }
 
-/** How far a read reaches back before the last one: room for a clock that differs from GitHub's. */
-const SINCE_MARGIN_MS = 5 * 60_000
+/**
+ * How far a read reaches back before the last one: room for a clock that differs from GitHub's, and the round of a
+ * bot's comment (`ROUND_WINDOW_MS`), so its inline comments are read with it.
+ */
+const SINCE_MARGIN_MS = ROUND_WINDOW_MS
 /** The latest time a JavaScript date holds; a stored `since` past it cannot come from a read. */
 const LATEST_TIME_MS = 8.64e15
 /** GitHub's review states as the REST API spells them. */
@@ -135,6 +123,20 @@ export const parseFeedbackLines = (text: string, form: FeedbackForm, pullRequest
       return itemOf(value, form, number)
     })
 
+/**
+ * Whose feedback does not count: the account the watcher runs as, the config's ignored logins (`feedback.ignore`) and
+ * the preview authors, with the texts of a bot's comment that reports no finding.
+ */
+export const feedbackFilterOf = (
+  own: string,
+  feedback: Pick<FeedbackConfig, 'ignore' | 'noFindingTemplates'>,
+  previewAuthors: readonly string[],
+): FeedbackFilter => ({
+  own,
+  ignore: [...feedback.ignore, ...previewAuthors],
+  noFindingTemplates: feedback.noFindingTemplates,
+})
+
 /** A review without text that only carries inline comments; those are reported on their own. */
 const isReviewShell = (item: FeedbackItem): boolean =>
   item.form === FEEDBACK_FORM.review && item.state === REVIEW_STATE.commented && item.body.trim() === ''
@@ -156,7 +158,10 @@ const requestsChanges = (items: readonly FeedbackItem[]): boolean => {
   return [...verdicts.values()].includes(REVIEW_STATE.changesRequested)
 }
 
-/** The read with only the targets' feedback that counts: no own answers, no ignored authors, no empty review shells. */
+/**
+ * The read with only the targets' feedback that counts: no own answers, no ignored authors, no empty review shells,
+ * no bot comment that reports no finding.
+ */
 export const feedbackReadOf = (
   readAt: number,
   targets: FeedbackTarget[],
@@ -165,7 +170,11 @@ export const feedbackReadOf = (
 ): FeedbackRead => {
   const numbers = new Set(targets.map(({ number }) => number))
   const counted = items.filter(
-    (item) => numbers.has(item.pullRequest) && !isFiltered(item.author, filter) && !isReviewShell(item),
+    (item) =>
+      numbers.has(item.pullRequest) &&
+      !isFiltered(item.author, filter) &&
+      !isReviewShell(item) &&
+      !isNoFindingComment(item, items, filter.noFindingTemplates),
   )
   const changesRequested = targets
     .map(({ number }) => number)

package/src/watch/gh-process.ts

@@ -0,0 +1,53 @@
+import { errorText } from '../plans/error-text'
+
+/** The answer of one `gh` call: its output, or the reason it failed (exit code, stderr, gh not installed). */
+export type GhAnswer = { ok: true; stdout: string } | { ok: false; error: string }
+
+/**
+ * `timeoutMs` ends a call that has not finished by then; without it the call waits as long as `gh` does.
+ * `tailChars` keeps only that many characters from the end of the output: stdout is read as a stream and never held
+ * whole, so memory stays near twice `tailChars` however much `gh` prints. `executable` replaces the `gh` that is run,
+ * for a test that stands in for it.
+ */
+export type GhOptions = { timeoutMs?: number; tailChars?: number; executable?: string }
+
+const readTail = async (stream: ReadableStream<Uint8Array>, tailChars: number): Promise<string> => {
+  const decoder = new TextDecoder()
+  let tail = ''
+  for await (const chunk of stream) {
+    tail += decoder.decode(chunk, { stream: true })
+    if (tail.length > 2 * tailChars) tail = tail.slice(-tailChars)
+  }
+  return (tail + decoder.decode()).slice(-tailChars)
+}
+
+const readOutput = (stream: ReadableStream<Uint8Array>, tailChars: number | undefined): Promise<string> =>
+  tailChars === undefined ? new Response(stream).text() : readTail(stream, tailChars)
+
+/** Runs `gh` in `cwd`; never rejects, so a caller decides what a failed call means. */
+export const runGh = async (args: string[], cwd: string, options: GhOptions = {}): Promise<GhAnswer> => {
+  const command = `gh ${args.slice(0, 2).join(' ')}`
+  let timedOut = false
+  let timer: ReturnType<typeof setTimeout> | undefined
+  try {
+    const child = Bun.spawn([options.executable ?? 'gh', ...args], { cwd, stdout: 'pipe', stderr: 'pipe' })
+    if (options.timeoutMs !== undefined)
+      timer = setTimeout(() => {
+        timedOut = true
+        child.kill()
+      }, options.timeoutMs)
+    const [stdout, stderr, exitCode] = await Promise.all([
+      readOutput(child.stdout, options.tailChars),
+      new Response(child.stderr).text(),
+      child.exited,
+    ])
+    if (exitCode === 0) return { ok: true, stdout }
+    if (timedOut) return { ok: false, error: `${command}: timed out after ${(options.timeoutMs ?? 0) / 1000} s` }
+    const reason = stderr.trim().replace(/\s*\n\s*/g, ' ') || `exit ${exitCode}`
+    return { ok: false, error: `${command}: ${reason}` }
+  } catch (error) {
+    return { ok: false, error: `${command}: ${errorText(error)}` }
+  } finally {
+    clearTimeout(timer)
+  }
+}

package/src/watch/gh.ts

@@ -1,22 +1,12 @@
-import { errorText } from '../plans/error-text'
+import { type GhAnswer, type GhOptions, runGh as runGhProcess } from './gh-process'
 
-/** The answer of one `gh` call: its output, or the reason it failed (exit code, stderr, gh not installed). */
-export type GhAnswer = { ok: true; stdout: string } | { ok: false; error: string }
+export type { GhAnswer, GhOptions }
 
-/** Runs `gh` in `cwd`; never rejects, so a caller decides what a failed call means. */
-export const runGh = async (args: string[], cwd: string): Promise<GhAnswer> => {
-  const command = `gh ${args.slice(0, 2).join(' ')}`
-  try {
-    const child = Bun.spawn(['gh', ...args], { cwd, stdout: 'pipe', stderr: 'pipe' })
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(child.stdout).text(),
-      new Response(child.stderr).text(),
-      child.exited,
-    ])
-    if (exitCode === 0) return { ok: true, stdout }
-    const reason = stderr.trim().replace(/\s*\n\s*/g, ' ') || `exit ${exitCode}`
-    return { ok: false, error: `${command}: ${reason}` }
-  } catch (error) {
-    return { ok: false, error: `${command}: ${errorText(error)}` }
-  }
-}
+/**
+ * The seam the watcher's readers call `gh` through, and the module their tests replace with `mock.module('./gh')`.
+ * Bun keeps such a mock for the rest of the process and rewrites the exports of a module already loaded, a re-export
+ * included, so `runGh` here is a binding of its own and the real runner in `gh-process.ts` stays reachable for its
+ * test whatever file ran before.
+ */
+export const runGh = (args: string[], cwd: string, options?: GhOptions): Promise<GhAnswer> =>
+  runGhProcess(args, cwd, options)

package/src/watch/heartbeat-progress.ts

@@ -2,7 +2,7 @@ import { currentPhase, type LaneProgress, PHASE_ID_PREFIX, type PhaseProgress }
 import { AGENT_STATUS } from '../terminal/types'
 import type { LaneSnapshot } from './lane-watch'
 
-/** The current phase of a lane and how many of its checkboxes are ticked, as the plans view counts them. */
+/** The current phase of a lane and how many of its checkboxes are ticked, as the herd counts them. */
 export type PhaseCount = Pick<PhaseProgress, 'id' | 'done' | 'total'>
 
 /** What a heartbeat adds to a working lane, by lane name: `P12 7/12`, without the middle dot of `shortTitle`, which the heartbeat's separator rewrite would turn into a slash. */

package/src/watch/lane-model.ts

@@ -0,0 +1,54 @@
+import { differsFromColumn } from '../plan-format'
+import { isRecord } from './json-guards'
+
+export const LANE_MODEL_EVENT = 'model'
+
+/** Lane → the differing model last reported for its agent; a lane without an entry runs a fitting model or is unread. */
+export type LaneModels = Record<string, string>
+
+/**
+ * The model of a lane's last answer (null without one), whether its agent is idle (`done` or `idle`: neither working
+ * nor waiting for an answer, so it can be switched), and its board row's model column.
+ */
+export type LaneModelReading = { model: string | null; idle: boolean; column: string }
+
+export type LaneModelEvent = { kind: typeof LANE_MODEL_EVENT; lane: string; model: string; column: string }
+
+const differs = (reading: LaneModelReading): reading is LaneModelReading & { model: string } =>
+  reading.model !== null && differsFromColumn(reading.column, reading.model)
+
+/**
+ * One event per idle lane whose model fits none of its column and differs from the one last reported: once per
+ * deviation, again only after the model changed. A lane that is not idle waits, since a lane is switched only while idle.
+ */
+export const laneModelEvents = (previous: LaneModels, readings: Record<string, LaneModelReading>): LaneModelEvent[] =>
+  Object.entries(readings).flatMap(([lane, reading]) => {
+    return differs(reading) && reading.idle && reading.model !== previous[lane]
+      ? [{ kind: LANE_MODEL_EVENT, lane, model: reading.model, column: reading.column }]
+      : []
+  })
+
+const recordedModel = (reported: string | undefined, reading: LaneModelReading | undefined): string | undefined => {
+  if (!reading || reading.model === null) return reported
+  if (!differs(reading)) return undefined
+  return reading.idle ? reading.model : reported
+}
+
+/**
+ * The models after a read: an idle lane keeps the differing model it reported, a fitting model clears the entry,
+ * a lane that is not idle and one without a reading keep what they had; a lane no longer watched is dropped.
+ */
+export const recordLaneModels = (
+  previous: LaneModels,
+  readings: Record<string, LaneModelReading>,
+  lanes: readonly string[],
+): LaneModels =>
+  Object.fromEntries(
+    lanes.flatMap((lane) => {
+      const model = recordedModel(previous[lane], readings[lane])
+      return model === undefined ? [] : [[lane, model]]
+    }),
+  )
+
+export const isLaneModels = (value: unknown): value is LaneModels =>
+  isRecord(value) && Object.values(value).every((model) => typeof model === 'string')

package/src/watch/lane-parallel.ts

@@ -0,0 +1,46 @@
+import { isRecord } from './json-guards'
+
+export const LANE_PARALLEL_EVENT = 'parallel'
+
+/** Lane → the phases last reported as able to run together; a lane without an entry has none to report. */
+export type LaneParallels = Record<string, string[]>
+
+export type LaneParallelEvent = { kind: typeof LANE_PARALLEL_EVENT; lane: string; phases: string[] }
+
+const MIN_PHASES = 2
+
+/** The first group of `parallelGroups` with at least two phases, which is what the watcher reports; empty without one. */
+export const parallelBatchOf = (groups: readonly string[][]): string[] =>
+  groups.find((group) => group.length >= MIN_PHASES) ?? []
+
+const sameAs = (left: readonly string[] | undefined, right: readonly string[]): boolean =>
+  left !== undefined && left.length === right.length && left.every((id, index) => id === right[index])
+
+/**
+ * One event per lane whose plan has two phases or more that can run together and that differ from the ones last
+ * reported: once per set, again only after the set changed or after a read without any.
+ */
+export const laneParallelEvents = (previous: LaneParallels, readings: Record<string, string[]>): LaneParallelEvent[] =>
+  Object.entries(readings).flatMap(([lane, phases]) =>
+    phases.length >= MIN_PHASES && !sameAs(previous[lane], phases) ? [{ kind: LANE_PARALLEL_EVENT, lane, phases }] : [],
+  )
+
+/**
+ * The phases after a read: a lane with two phases or more keeps them, a shorter reading clears the entry, a lane
+ * without a reading keeps what it had; a lane no longer watched is dropped.
+ */
+export const recordLaneParallels = (
+  previous: LaneParallels,
+  readings: Record<string, string[]>,
+  lanes: readonly string[],
+): LaneParallels =>
+  Object.fromEntries(
+    lanes.flatMap((lane) => {
+      const phases = readings[lane] ?? previous[lane]
+      return phases !== undefined && phases.length >= MIN_PHASES ? [[lane, phases]] : []
+    }),
+  )
+
+export const isLaneParallels = (value: unknown): value is LaneParallels =>
+  isRecord(value) &&
+  Object.values(value).every((phases) => Array.isArray(phases) && phases.every((id) => typeof id === 'string'))

package/src/watch/lane-progress.ts

@@ -1,13 +1,15 @@
-import { dirname } from 'node:path'
-import type { LaneProgress, SprintLane } from '../plan-format'
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { type LaneProgress, parallelGroupsOfPlan, resolvePlanPath, type SprintLane } from '../plan-format'
 import { boardRowsOf } from '../plans/board-rows'
 import { baseReaderOf, gitStatusOf } from '../plans/git'
 import { laneWorkOf, readPlans, textAtBase } from '../plans/lane-plans'
 import { baseRefOf, boardRepoPathOf, type PlansSettings, worktreeOf } from '../plans/settings'
 import { workedLaneProgress } from '../plans/worked-phases'
+import { parallelBatchOf } from './lane-parallel'
 
 /**
- * The progress the watcher reports for a lane, from the same reading as the plans view: the base ref's plans, the
+ * The progress the watcher reports for a lane, from the same reading as the herd: the base ref's plans, the
  * phases the lane works on from its worktree (also without a board row), so both name the same open phase.
  */
 export const watchedLaneProgress = async (
@@ -30,7 +32,29 @@ export const watchedLaneProgress = async (
 }
 
 /**
- * The rows the checkout's board file (`checkoutText`) has beyond the board at the base ref, counted as the plans view
+ * The phases of a lane's plan (the plan of its newest row, as the lane's worktree has it, else as the base ref has
+ * it) that can run together, by the plan's dependency table and ticks; empty without a plan, without a table or
+ * without two such phases.
+ */
+export const watchedLaneParallel = (
+  root: string,
+  settings: PlansSettings,
+  boardFile: string,
+  lane: SprintLane,
+): string[] => {
+  const href = lane.steps.filter((step) => step.planHref !== null).at(-1)?.planHref
+  if (!href) return []
+  const path = resolvePlanPath(dirname(boardRepoPathOf(root, settings, boardFile)), href)
+  const worktreeFile = join(worktreeOf(root, settings, lane.name), path)
+  const text = existsSync(worktreeFile)
+    ? readFileSync(worktreeFile, 'utf8')
+    : textAtBase(baseReaderOf(root, baseRefOf(settings)), path)
+  const groups = text === null ? null : parallelGroupsOfPlan(text, settings.planLanguage)
+  return groups === null ? [] : parallelBatchOf(groups)
+}
+
+/**
+ * The rows the checkout's board file (`checkoutText`) has beyond the board at the base ref, counted as the herd
  * adds them; 0 when the base ref lacks the board, which is then read from the checkout as a whole.
  */
 export const boardCheckoutRows = (

package/src/watch/lane-report.ts

@@ -1,10 +1,14 @@
 import { CONTEXT_LEVEL, type ContextLevel, contextLabel } from '../context'
-import { currentPhase, isTickedUnmerged, type LaneProgress } from '../plan-format'
+import { currentPhase, isTickedUnmerged, type LaneProgress, phasesText } from '../plan-format'
 import { terminalSafe } from '../plan-format/terminal-text'
-import type { ChecksState } from '../plans/pull-requests'
+import { CHECK_NAME_LENGTH, type ChecksState } from '../plans/pull-requests'
+import { shownWithMore } from '../plans/shown-with-more'
+import type { ApprovalEvent } from './approvals'
 import type { CoordinatorRead } from './coordinator-fill'
 import { type FeedbackEvent, firstLine } from './feedback'
 import type { LaneFillEvent } from './lane-fill'
+import type { LaneModelEvent } from './lane-model'
+import type { LaneParallelEvent } from './lane-parallel'
 import { AGENT_STATUS, type LaneSnapshot, NO_AGENT } from './lane-watch'
 import { PULL_REQUEST_STATE, type WatchedPullRequest } from './pull-requests'
 import { SOURCE_FIELD } from './source-fields'
@@ -44,6 +48,8 @@ const REPORT_INDENT = '  '
 const SHORT_SHA_LENGTH = 7
 const NO_REMINDER: BoardReminder = { term: '', checkoutRows: 0 }
 const OTHER_PULL_REQUEST_LIMIT = 5
+const FAILED_TEST_LENGTH = 100
+const FAILED_TESTS_IN_LINE = 5
 
 const pullRequestSegment = (pullRequest: LaneReport['pullRequest'], texts: WatchTexts): string => {
   if (!pullRequest) return texts.noPullRequest
@@ -90,6 +96,18 @@ const deployOwner = (event: DeployEvent): string => {
   return event.pullRequest === undefined ? 'manual' : `#${event.pullRequest}`
 }
 
+/** `: test, lint (3 tests: a, b, c +1)` after a red pull request's header; empty without a failed check's name. */
+const failedChecksSuffix = (event: PullRequestEvent): string => {
+  if (event.kind !== WATCH_EVENT.checksFailed || !event.failedChecks?.length) return ''
+  const checks = event.failedChecks.map((name) => terminalSafe(name).slice(0, CHECK_NAME_LENGTH)).join(', ')
+  const tests = event.failedTests ?? []
+  if (tests.length === 0) return `: ${checks}`
+  const { shown, more } = shownWithMore(tests, FAILED_TESTS_IN_LINE)
+  const names = shown.map((name) => terminalSafe(name).slice(0, FAILED_TEST_LENGTH)).join(', ')
+  const count = `${tests.length} ${tests.length === 1 ? 'test' : 'tests'}`
+  return `: ${checks} (${count}: ${names}${more > 0 ? ` +${more}` : ''})`
+}
+
 /**
  * `other PRs: #<n> passed · #<m> none`, in the words of `texts`: the open pull requests among `own` (the user's own without a
  * lane), newest first, at most `OTHER_PULL_REQUEST_LIMIT` and `+<k>` for the rest; null when there is none.
@@ -103,13 +121,14 @@ export const otherPullRequestsLine = (
     .filter(({ number, state }) => state === PULL_REQUEST_STATE.open && own.includes(number))
     .sort((left, right) => right.number - left.number)
   if (open.length === 0) return null
-  const shown = open.slice(0, OTHER_PULL_REQUEST_LIMIT).map(({ number, checks }) => `#${number} ${checks}`)
-  const more = open.length - OTHER_PULL_REQUEST_LIMIT
-  return `${texts.otherPullRequests}: ${[...shown, ...(more > 0 ? [`+${more}`] : [])].join(' · ')}`
+  const { shown, more } = shownWithMore(open, OTHER_PULL_REQUEST_LIMIT)
+  const named = shown.map(({ number, checks }) => `#${number} ${checks}`)
+  return `${texts.otherPullRequests}: ${[...named, ...(more > 0 ? [`+${more}`] : [])].join(' · ')}`
 }
 
 /**
- * The header line of one event: `=== merged #<number> (lane)`, `=== checks failed #<number> (lane|branch <name>)`,
+ * The header line of one event: `=== merged #<number> (lane)`, `=== checks failed #<number> (lane|branch <name>): <checks> (<k> tests: <names>)`,
+ * the checks and tests only when the event carries them,
  * `=== deploy success run 9 (push, lane|#<number>) target stage`, `=== heartbeat`, `=== gh unavailable: <reason>`,
  * `=== coordinator warn 62 %`, `=== lane <name> alert 47 %`, `=== preview #<number> (lane) <url> · <sha7>`.
  * `target` is the deploy environment read from the run, null when none was found.
@@ -126,8 +145,15 @@ export const watchEventLine = (event: WatchEvent, target: string | null): string
     return `=== ${event.kind} #${event.number} (${terminalSafe(event.lane)}) ${terminalSafe(event.url)} · ${terminalSafe(event.headCommit.slice(0, SHORT_SHA_LENGTH))}`
   if (event.kind === WATCH_EVENT.laneFill)
     return `=== ${event.kind} ${terminalSafe(event.lane)} ${event.level} ${contextLabel(event.share)}`
+  if (event.kind === WATCH_EVENT.laneModel)
+    return `=== ${event.kind} ${terminalSafe(event.lane)} ${terminalSafe(event.model)} · board ${terminalSafe(event.column)}`
+  if (event.kind === WATCH_EVENT.laneParallel)
+    return `=== ${event.kind} ${terminalSafe(event.lane)} ${phasesText(event.phases)}`
+  if (event.kind === WATCH_EVENT.approval)
+    return `=== ${event.kind} ${terminalSafe(event.lane)} ${event.id} ${terminalSafe(event.tool)} · ${terminalSafe(event.summary)}`
   if (event.kind === WATCH_EVENT.coordinator) return `=== ${event.kind} ${event.level} ${contextLabel(event.share)}`
-  if (isPullRequestEvent(event)) return `=== ${event.kind} #${event.number} (${pullRequestOwner(event)})`
+  if (isPullRequestEvent(event))
+    return `=== ${event.kind} #${event.number} (${pullRequestOwner(event)})${failedChecksSuffix(event)}`
   if ('number' in event) return `=== ${event.kind} #${event.number} (${terminalSafe(event.lane)})`
   return `=== ${event.kind}`
 }
@@ -138,11 +164,11 @@ export const watchEventLine = (event: WatchEvent, target: string | null): string
  */
 export const feedbackEventLines = (event: FeedbackEvent): string[] => {
   const header = `=== ${event.kind} #${event.number} (${terminalSafe(event.lane)}) ${terminalSafe(event.author)} ${terminalSafe(event.label)} · ${event.entries.length} new`
-  const entries = event.entries.slice(0, FEEDBACK_ENTRY_LIMIT).map(({ place, text }) => {
+  const { shown: shownEntries, more } = shownWithMore(event.entries, FEEDBACK_ENTRY_LIMIT)
+  const entries = shownEntries.map(({ place, text }) => {
     const line = terminalSafe(place === null ? text : `${place} ${text}`).slice(0, REPORT_TEXT_LENGTH)
     return `${REPORT_INDENT}${line}`
   })
-  const more = event.entries.length - FEEDBACK_ENTRY_LIMIT
   return [header, ...entries, ...(more > 0 ? [`${REPORT_INDENT}… ${more} more`] : [])]
 }
 
@@ -246,6 +272,33 @@ export const laneFillDutyLines = (events: readonly WatchEvent[], texts: WatchTex
     .filter(isLaneAlert)
     .map(({ lane }) => `${terminalSafe(lane)} context ${CONTEXT_LEVEL.alert}: ${texts.laneAlertDuty}`)
 
+const isLaneModel = (event: WatchEvent): event is LaneModelEvent => event.kind === WATCH_EVENT.laneModel
+
+/** What a lane whose model fits none of its model column asks of the coordinator (`orchestrate` § 2): one line per such lane. */
+export const laneModelDutyLines = (events: readonly WatchEvent[], texts: WatchTexts): string[] =>
+  events
+    .filter(isLaneModel)
+    .map(({ lane, model }) => `${terminalSafe(lane)} model ${terminalSafe(model)}: ${texts.laneModelDuty}`)
+
+const isLaneParallel = (event: WatchEvent): event is LaneParallelEvent => event.kind === WATCH_EVENT.laneParallel
+
+/** What phases of one lane that can run together ask of the coordinator (`orchestrate` § 4): one line per such lane. */
+export const parallelDutyLines = (events: readonly WatchEvent[], texts: WatchTexts): string[] =>
+  events
+    .filter(isLaneParallel)
+    .map(({ lane, phases }) => `${terminalSafe(lane)} parallel: ${texts.parallelDuty(phasesText(phases))}`)
+
+const isApproval = (event: WatchEvent): event is ApprovalEvent => event.kind === WATCH_EVENT.approval
+
+/**
+ * What a lane's call waiting for approval asks of the coordinator (`orchestrate` § 4): one line per request, naming the
+ * mark the question carries and the two labels the hook matches.
+ */
+export const approvalDutyLines = (events: readonly WatchEvent[], texts: WatchTexts): string[] =>
+  events
+    .filter(isApproval)
+    .map(({ lane, id, hash }) => `${terminalSafe(lane)} approval ${id}: ${texts.approvalDuty(id, hash)}`)
+
 /**
  * What a blocked lane asks of the coordinator (`orchestrate` § 4), one line per stopped lane that
  * sits in `blocked`: vet the question, answer it in the lane or ask the user, never hand the pane

package/src/watch/lane-sources.ts

@@ -33,7 +33,7 @@ export const branchOf = (worktree: string): string | null =>
 
 /**
  * Fetches the base branch when the remote moved past `origin/<branch>`, so every reader of that ref
- * (the plans view watches `FETCH_HEAD`) sees a merge as soon as the watcher does. Asks the remote
+ * (the herd watches `FETCH_HEAD`) sees a merge as soon as the watcher does. Asks the remote
  * first, so an unchanged base costs no fetch; a failure leaves the ref as it is.
  */
 export const fetchBaseWhenMoved = async (root: string, branch: string): Promise<void> => {

package/src/watch/no-finding.ts

@@ -0,0 +1,47 @@
+import { FEEDBACK_FORM, type FeedbackItem } from './feedback-item'
+
+/**
+ * How far apart a bot's comment and its inline comments may be and still belong to one round: a review posts its
+ * inline comments and its summary within moments, and a read reaches back by the same margin.
+ */
+export const ROUND_WINDOW_MS = 5 * 60_000
+
+const BOT_SUFFIX = '[bot]'
+
+/** GitHub names the login of every app account with the suffix `[bot]`; logins ignore case. */
+export const isBotLogin = (login: string): boolean => login.toLowerCase().endsWith(BOT_SUFFIX)
+
+/** Trimmed, every run of whitespace (line breaks included) as one space. */
+export const normalisedText = (text: string): string => text.trim().replace(/\s+/g, ' ')
+
+const isInRound = (comment: FeedbackItem, other: FeedbackItem): boolean => {
+  const distance = Math.abs(Date.parse(comment.createdAt) - Date.parse(other.createdAt))
+  return distance <= ROUND_WINDOW_MS
+}
+
+const hasInlineInRound = (comment: FeedbackItem, items: readonly FeedbackItem[]): boolean =>
+  items.some(
+    (other) =>
+      other.form === FEEDBACK_FORM.inline &&
+      other.pullRequest === comment.pullRequest &&
+      other.author.toLowerCase() === comment.author.toLowerCase() &&
+      isInRound(comment, other),
+  )
+
+/**
+ * True for a pull request comment of a bot that reports no finding: its text equals one of `templates` once both are
+ * normalised, and the same author left no inline comment on the pull request in the same round, which is the time
+ * window `ROUND_WINDOW_MS` around the comment's creation. A comment whose time cannot be read is never one: the guess
+ * would drop feedback. `items` are all the feedback read, the inline comments among them.
+ */
+export const isNoFindingComment = (
+  comment: FeedbackItem,
+  items: readonly FeedbackItem[],
+  templates: readonly string[],
+): boolean => {
+  if (comment.form !== FEEDBACK_FORM.comment || !isBotLogin(comment.author)) return false
+  if (Number.isNaN(Date.parse(comment.createdAt))) return false
+  const text = normalisedText(comment.body)
+  const matches = text !== '' && templates.some((template) => normalisedText(template) === text)
+  return matches && !hasInlineInRound(comment, items)
+}

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

@@ -1,6 +1,13 @@
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { WATCH_HEALTH, type WatchReading, watchBadgesOf, watchHealthOf } from './plan-badges'
+import {
+  sourceTicketsOf,
+  type TicketSource,
+  WATCH_HEALTH,
+  type WatchReading,
+  watchBadgesOf,
+  watchHealthOf,
+} from './plan-badges'
 import { parseWatchState, type WatchState } from './watch-events'
 import { type CommandLineOf, isWatcherRunning, WATCHER_FILES, watcherDirectoryOf } from './watcher-lock'
 
@@ -13,11 +20,16 @@ const readState = (file: string): WatchState | null => {
 }
 
 /**
- * What the watcher of the repository at `root` gives the plans view, read from its state file without a GitHub call:
- * its badges, and its health, so the view can say why there are none. A missing or damaged file shows no badges; the
- * view goes on without them.
+ * What the watcher of the repository at `root` gives the herd, read from its state file without a GitHub call:
+ * its badges, the tickets of `ticketSources`, and its health, so the view can say why there are none. A missing or
+ * damaged file shows no badges; the view goes on without them.
  */
-export const readWatchReading = (root: string, now: number, lookUp?: CommandLineOf): WatchReading => {
+export const readWatchReading = (
+  root: string,
+  now: number,
+  ticketSources: readonly TicketSource[],
+  lookUp?: CommandLineOf,
+): WatchReading => {
   const directory = watcherDirectoryOf(root)
   const state = readState(join(directory, WATCHER_FILES.state))
   const health = watchHealthOf(
@@ -25,6 +37,6 @@ export const readWatchReading = (root: string, now: number, lookUp?: CommandLine
     isWatcherRunning(join(directory, WATCHER_FILES.lock), lookUp),
     now,
   )
-  const badges = state && health.kind === WATCH_HEALTH.live ? watchBadgesOf(state, now) : {}
-  return { badges, health }
+  if (!state || health.kind !== WATCH_HEALTH.live) return { badges: {}, tickets: [], health }
+  return { badges: watchBadgesOf(state, now), tickets: sourceTicketsOf(state, ticketSources, now), health }
 }