jackherd 1.6.0 → 1.7.0

package/src/watch/plan-badges.ts

@@ -1,11 +1,22 @@
+import { CHECKS } from '../plans/pull-requests'
+import { sanitisedFailedTests } from './failed-tests'
+import { failedTestsOf } from './failures'
+import { previewUrlOf } from './previews'
 import { PULL_REQUEST_STATE } from './pull-requests'
+import { lineText, type TicketRecord } from './sources'
 import type { WatchState } from './watch-events'
 
 /**
- * What the plans view shows beside a pull request: the checked URL of its preview, the feedback since its last push,
+ * What the herd shows beside a pull request: the checked URL of its preview, the feedback since its last push,
  * and whether a reviewer requests changes.
  */
-export type PullRequestBadges = { preview: string | null; feedback: number; changesRequested: boolean }
+export type PullRequestBadges = {
+  preview: string | null
+  feedback: number
+  changesRequested: boolean
+  /** The tests a red run failed on this head commit, as the watcher read them from the run's log; absent reads as none. */
+  failedTests?: string[]
+}
 
 /** The badges of a pull request the watcher shows nothing for. */
 export const NO_BADGES: PullRequestBadges = { preview: null, feedback: 0, changesRequested: false }
@@ -22,14 +33,29 @@ export type WatchHealth =
   | { kind: typeof WATCH_HEALTH.off }
   | { kind: typeof WATCH_HEALTH.stale; minutes: number }
 
-/** The badges the view draws and why there may be none. */
-export type WatchReading = { badges: WatchBadges; health: WatchHealth }
+/** A source marked `ticket` in the config, with the lane its entries belong to, null when it names none. */
+export type TicketSource = { name: string; lane: string | null }
+
+/** A ticket as its badge shows it; `isNew` while its last reported change is younger than `NEW_FOR_MS`. */
+export type TicketBadge = { id: string; url: string | null; status: string | null; isNew: boolean }
+
+/** A ticket with the lane its source names, before the view matched it to a lane. */
+export type SourceTicket = TicketBadge & { lane: string | null }
+
+/** The badges the view draws, the tickets of the marked sources, and why there may be none. */
+export type WatchReading = { badges: WatchBadges; tickets: SourceTicket[]; health: WatchHealth }
 
 /** Three missed GitHub reads of the watcher (one a minute): an older state is not shown (D96). */
 export const STALE_AFTER_MS = 180_000
 
+/** How long a ticket stays marked new after its last reported change: a fixed day, no configuration. */
+export const NEW_FOR_MS = 24 * 60 * 60_000
+
 const MINUTE_MS = 60_000
 
+const shownFailedTestsOf = (state: WatchState, number: string, headCommit: string): string[] =>
+  sanitisedFailedTests(failedTestsOf(state.failures, Number(number), headCommit))
+
 const isFresh = (savedAt: number | null, now: number): boolean => savedAt !== null && now - savedAt <= STALE_AFTER_MS
 
 /**
@@ -44,23 +70,49 @@ export const watchHealthOf = (savedAt: number | null, running: boolean, now: num
 
 /**
  * The badges of the open pull requests the watcher follows, from its saved state alone: the preview reported for the
- * head the watcher knows, the feedback counted since that head, and the requested changes, which a push keeps. A value
+ * head the watcher knows, the feedback counted since that head, the requested changes, which a push keeps, and the tests
+ * a red run failed on that head. A value
  * of an older head, a preview recorded without its URL, and a state older than `STALE_AFTER_MS` show nothing.
  */
 export const watchBadgesOf = (state: WatchState, now: number): WatchBadges => {
   if (!isFresh(state.savedAt, now)) return {}
   return Object.fromEntries(
-    Object.entries(state.pullRequests).flatMap(([number, { state: prState, headCommit }]) => {
+    Object.entries(state.pullRequests).flatMap(([number, { state: prState, headCommit, checks }]) => {
       if (prState !== PULL_REQUEST_STATE.open) return []
       const preview = state.previews.pullRequests[number]
       const feedback = state.feedback.pullRequests[number]
+      const failedTests = checks === CHECKS.failed ? shownFailedTestsOf(state, number, headCommit) : []
       const badges = {
         preview: preview?.reportedHead === headCommit ? (preview.url ?? null) : null,
         feedback: feedback?.headCommit === headCommit ? feedback.count : 0,
         changesRequested: feedback?.changesRequested === true,
+        ...(failedTests.length > 0 && { failedTests }),
       }
-      const shown = badges.preview !== null || badges.feedback > 0 || badges.changesRequested
+      const shown = badges.preview !== null || badges.feedback > 0 || badges.changesRequested || failedTests.length > 0
       return shown ? [[number, badges]] : []
     }),
   )
 }
+
+const ticketBadgeOf = (id: string, { url, status, changedAt }: TicketRecord, now: number): TicketBadge => ({
+  id: lineText(id),
+  url: url === null ? null : previewUrlOf(url, undefined),
+  status: status === null ? null : lineText(status) || null,
+  isNew: changedAt !== null && now - changedAt < NEW_FOR_MS,
+})
+
+/**
+ * The tickets of the sources the config marks, in their order, from the watcher's saved state alone. Id and status
+ * are drawn as one line and the URL is checked again, since the view does not trust the file more than the watcher
+ * trusted the source; an id that is empty on one line is dropped, and a state older than `STALE_AFTER_MS` shows none,
+ * as for the pull request badges.
+ */
+export const sourceTicketsOf = (state: WatchState, sources: readonly TicketSource[], now: number): SourceTicket[] => {
+  if (!isFresh(state.savedAt, now)) return []
+  return sources.flatMap(({ name, lane }) =>
+    Object.entries(state.sources[name]?.tickets ?? {}).flatMap(([id, record]) => {
+      const badge = ticketBadgeOf(id, record, now)
+      return badge.id === '' ? [] : [{ ...badge, lane }]
+    }),
+  )
+}

package/src/watch/plan-views.ts

@@ -6,14 +6,14 @@ import type { LaneSnapshot } from './lane-watch'
 export const ENSURE_TRIGGER = { start: 'start', poll: 'poll' } as const
 
 /**
- * Why the watcher may bring back plans views: its own start, or a poll that found lanes added to the watched set
+ * Why the watcher may bring back herd panes: its own start, or a poll that found lanes added to the watched set
  * or watched lanes whose agent appeared (a lane gets its view only once its agent runs).
  */
 export type EnsureTrigger =
   | { kind: typeof ENSURE_TRIGGER.start }
   | { kind: typeof ENSURE_TRIGGER.poll; added: string[]; withNewAgent: string[] }
 
-/** Whether the last failure of `plans --ensure` was already printed; a run that works clears it. */
+/** Whether the last failure of `herd --ensure` was already printed; a run that works clears it. */
 export type PlanViews = { failureReported: boolean }
 
 type Ensured = { ok: true; lines: string[] } | { ok: false; error: string }
@@ -34,9 +34,9 @@ export const ensureDue = (trigger: EnsureTrigger): boolean =>
 /** The lines one run leaves in the watcher's output: what it brought back, or a failure once per streak. */
 export const ensuredLines = (ensured: Ensured, views: PlanViews): { lines: string[]; views: PlanViews } => {
   if (ensured.ok)
-    return { lines: ensured.lines.map((line) => `plans --ensure: ${line}`), views: { failureReported: false } }
+    return { lines: ensured.lines.map((line) => `herd --ensure: ${line}`), views: { failureReported: false } }
   if (views.failureReported) return { lines: [], views }
-  return { lines: [`plans --ensure failed, still watching: ${ensured.error}`], views: { failureReported: true } }
+  return { lines: [`herd --ensure failed, still watching: ${ensured.error}`], views: { failureReported: true } }
 }
 
 const ensuredOf = (ensure: () => string[]): Ensured => {
@@ -48,7 +48,7 @@ const ensuredOf = (ensure: () => string[]): Ensured => {
 }
 
 /**
- * Brings back missing plans views when `trigger` calls for it, as `jh plans --ensure` does. A failure
+ * Brings back missing herd panes when `trigger` calls for it, as `jh herd --ensure` does. A failure
  * never ends the watch; it is printed once until a run works again.
  */
 export const keepPlanViews = (trigger: EnsureTrigger, views: PlanViews, effects: Effects): PlanViews => {

package/src/watch/previews.ts

@@ -1,4 +1,5 @@
-import { FEEDBACK_FORM, type FeedbackFilter, type FeedbackItem, type FeedbackTarget, isReadTime } from './feedback'
+import { type FeedbackTarget, isReadTime } from './feedback'
+import { FEEDBACK_FORM, type FeedbackItem } from './feedback-item'
 import { isRecord } from './json-guards'
 
 export const PREVIEW_EVENT = 'preview'
@@ -25,7 +26,7 @@ export type PreviewCandidate = {
 
 /**
  * `reportedHead` is the head a preview was last reported (or, at the first sighting, found) for, `url` that preview's
- * checked URL (missing in a state written before the plans view showed it); `stamps` maps `key` to `stamp`.
+ * checked URL (missing in a state written before the herd showed it); `stamps` maps `key` to `stamp`.
  */
 export type PreviewRecord = { reportedHead: string | null; stamps: Record<string, string>; url?: string | null }
 
@@ -72,13 +73,6 @@ export const previewUrlOf = (text: string, pattern: string | undefined): string
 export const isPreviewAuthor = (author: string, authors: readonly string[]): boolean =>
   authors.some((name) => name.toLowerCase() === author.toLowerCase())
 
-/** Whose comments are no feedback: the account the watcher runs as, the ignored logins and the preview authors. */
-export const feedbackFilterOf = (
-  own: string,
-  ignore: readonly string[],
-  previews: Pick<PreviewSettings, 'authors'> | undefined,
-): FeedbackFilter => ({ own, ignore: [...ignore, ...(previews?.authors ?? [])] })
-
 /**
  * Whether the feedback read, which reached back from its own last read, also covers everything since the previews'
  * last read; a first preview read is a baseline and needs no history.

package/src/watch/pull-requests.ts

@@ -1,5 +1,12 @@
 import { terminalSafe } from '../plan-format/terminal-text'
-import { type ChecksState, checksOf, type GhPullRequest, isGhPullRequest } from '../plans/pull-requests'
+import {
+  type ChecksState,
+  checksOf,
+  type FailedCheck,
+  failedChecksOf,
+  type GhPullRequest,
+  isGhPullRequest,
+} from '../plans/pull-requests'
 import { isRecord, parseArray } from './json-guards'
 
 /** The states of a pull request in `gh pr list --json state`. */
@@ -13,6 +20,8 @@ export type WatchedPullRequest = {
   branch: string
   state: PullRequestLifecycle
   checks: ChecksState
+  /** The checks that failed with the run each belongs to; empty while none failed, and in the light list. */
+  failedRuns: FailedCheck[]
   headCommit: string
   mergeCommit: string | null
 }
@@ -66,6 +75,7 @@ const watchedPullRequestsOf = (
     branch: terminalSafe(pullRequest.headRefName),
     state: pullRequest.state,
     checks: checksOf(pullRequest.statusCheckRollup ?? []),
+    failedRuns: failedChecksOf(pullRequest.statusCheckRollup ?? [], pullRequest.url),
     headCommit: pullRequest.headRefOid,
     mergeCommit: pullRequest.mergeCommit?.oid ?? null,
   }))
@@ -73,7 +83,7 @@ const watchedPullRequestsOf = (
 const asIs = (entry: unknown): unknown => entry
 
 /**
- * Reads the JSON of `gh pr list --json <WATCHED_PULL_REQUEST_FIELDS>`, checked like the plans view's
+ * Reads the JSON of `gh pr list --json <WATCHED_PULL_REQUEST_FIELDS>`, checked like the herd's
  * `parsePullRequests`; throws on anything else. The list carries no rollup, so its checks are `none`.
  */
 export const parseWatchedPullRequests = (json: string, host = 'github.com'): WatchedPullRequest[] =>

package/src/watch/recorded-reads.ts

@@ -0,0 +1,25 @@
+import { type FailureReading, recordFailures } from './failures'
+import { type FeedbackRead, recordFeedback } from './feedback'
+import { type PreviewRead, recordPreviews } from './previews'
+import type { WatchedPullRequest } from './pull-requests'
+import type { WatchState } from './watch-events'
+
+/** What the last GitHub poll read besides the pull requests' state; a read that did not answer is null. */
+export type RecordedReads = {
+  feedback: FeedbackRead | null
+  previews: PreviewRead | null
+  pullRequests: readonly WatchedPullRequest[] | null
+  failures: readonly FailureReading[]
+}
+
+type Step = (state: WatchState) => WatchState
+
+const stepsOf = (reads: RecordedReads): Step[] => [
+  (state) => (reads.feedback ? { ...state, feedback: recordFeedback(state.feedback, reads.feedback) } : state),
+  (state) => ({ ...state, failures: recordFailures(state.failures, reads.pullRequests, reads.failures) }),
+  (state) => (reads.previews ? { ...state, previews: recordPreviews(state.previews, reads.previews) } : state),
+]
+
+/** The state after the feedback, failure and preview reads, each folded onto the result of the one before. */
+export const recordedReadsOf = (state: WatchState, reads: RecordedReads): WatchState =>
+  stepsOf(reads).reduce((current, step) => step(current), state)

package/src/watch/source-fields.ts

@@ -6,4 +6,8 @@ export const SOURCE_FIELD = {
   url: 'url',
   body: 'body',
   author: 'author',
+  status: 'status',
 } as const
+
+/** The fields a reader sees of an entry: a change of one of them is a change of the entry (`contentFingerprint`). */
+export const CONTENT_FIELDS = [SOURCE_FIELD.title, SOURCE_FIELD.author, SOURCE_FIELD.body, SOURCE_FIELD.url] as const

package/src/watch/source-tickets.ts

@@ -0,0 +1,99 @@
+import {
+  recordSources,
+  reportsItem,
+  SEEN_LIMIT,
+  type SeenEntry,
+  type SourceItem,
+  type SourceRecord,
+  type SourceRun,
+  type SourceSettings,
+  type SourceState,
+  seenMapOf,
+  type TicketRecord,
+} from './sources'
+
+const ticketOf = (
+  item: SourceItem,
+  known: TicketRecord | undefined,
+  seen: ReadonlyMap<string, SeenEntry> | null,
+  settings: SourceSettings,
+  now: number,
+): TicketRecord => ({
+  url: item.url,
+  status: item.status,
+  changedAt: seen && reportsItem(seen, item, settings) ? now : (known?.changedAt ?? null),
+})
+
+/** The tickets after a successful run: its entries, at most `SEEN_LIMIT`, each with the time of its last reported change. */
+const ticketsAfter = (
+  previous: SourceRecord | undefined,
+  items: readonly SourceItem[],
+  settings: SourceSettings,
+  now: number,
+): Record<string, TicketRecord> => {
+  const seen = seenMapOf(previous)
+  return Object.fromEntries(
+    items
+      .slice(-SEEN_LIMIT)
+      .map((item) => [item.id, ticketOf(item, previous?.tickets?.[item.id], seen, settings, now)]),
+  )
+}
+
+const withoutTickets = ({ tickets: _tickets, ...record }: SourceRecord): SourceRecord => record
+
+/** The tickets a source keeps: those of a successful run, else the ones it had; none for a source not marked. */
+const ticketsOf = (
+  previous: SourceRecord | undefined,
+  run: SourceRun | undefined,
+  settings: SourceSettings | undefined,
+  now: number,
+): Record<string, TicketRecord> | undefined => {
+  if (!settings?.ticket) return undefined
+  return run?.result.ok ? ticketsAfter(previous, run.result.items, settings, now) : previous?.tickets
+}
+
+/**
+ * The state `recordSources` wrote with the tickets of every source marked `ticket`: the entries of its last
+ * successful run with URL, status and the time the run that last reported a change of the entry was recorded at
+ * (`now`). A baseline run and a change by an ignored author record no time, an unchanged entry keeps its time, a
+ * failed run keeps the tickets, and a source no longer marked keeps none. `previous` is the state the runs were
+ * compared with, as for `sourceEvents`.
+ */
+const recordTickets = (
+  previous: SourceState,
+  recorded: SourceState,
+  runs: readonly SourceRun[],
+  settings: readonly SourceSettings[],
+  now: number,
+): SourceState =>
+  Object.fromEntries(
+    Object.entries(recorded).map(([name, record]) => {
+      const source = settings.find((candidate) => candidate.name === name)
+      const run = runs.find((candidate) => candidate.name === name)
+      const tickets = ticketsOf(previous[name], run, source, now)
+      return [name, tickets ? { ...withoutTickets(record), tickets } : withoutTickets(record)]
+    }),
+  )
+
+/**
+ * The source state after `runs`: `recordSources` for every configured source, then the tickets of the sources marked
+ * `ticket`, both against `previous`, the state the runs were compared with.
+ */
+export const recordWatchedSources = (
+  previous: SourceState,
+  runs: readonly SourceRun[],
+  settings: readonly SourceSettings[],
+  now: number,
+): SourceState =>
+  recordTickets(
+    previous,
+    recordSources(
+      previous,
+      runs,
+      settings.map(({ name }) => name),
+      now,
+    ),
+    runs,
+    settings,
+    now,
+  )

package/src/watch/sources.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto'
 import { terminalSafe } from '../plan-format/terminal-text'
 import { isRecord } from './json-guards'
 import { previewUrlOf } from './previews'
-import { SOURCE_FIELD } from './source-fields'
+import { CONTENT_FIELDS, SOURCE_FIELD } from './source-fields'
 import { ROOT_PATH, type SourcePath, selectPath } from './source-path'
 
 export const SOURCE_EVENT = 'source'
@@ -21,14 +21,18 @@ export const SOURCE_FAILURE = {
   shape: 'unexpected shape',
 } as const
 
-/** The paths of an entry's fields: `id` and `updatedAt`, the content fields, and any further named field. */
+/**
+ * The paths of an entry's fields: `id`, `updatedAt` (optional where a content field or `reportOn` tells a change), the
+ * content fields, and any further named field.
+ */
 export type SourceMap = {
   id: SourcePath
-  updatedAt: SourcePath
+  updatedAt?: SourcePath
   title?: SourcePath
   url?: SourcePath
   body?: SourcePath
   author?: SourcePath
+  status?: SourcePath
 } & Record<string, SourcePath | undefined>
 
 /**
@@ -46,6 +50,8 @@ export type SourceSettings = {
   lane?: string
   /** The mapped fields whose change reports, in place of the content fingerprint; without it the fingerprint decides. */
   reportOn?: readonly string[]
+  /** Its entries are tickets, which the state keeps for the herd's badges (`TicketRecord`). */
+  ticket?: boolean
 }
 
 /**
@@ -59,6 +65,8 @@ export type SourceItem = {
   url: string | null
   body: string
   author: string | null
+  /** `map.status` as the state keeps it (`storedValue`), null when not mapped or empty. */
+  status: string | null
   fingerprint: string
   /** The `reportOn` fields as the state keeps them (`storedValue`); empty without `reportOn`. */
   values: Record<string, string>
@@ -72,12 +80,23 @@ export type SourceRun = { name: string; result: SourceResult }
 /** `[id, fingerprint]`, or with `reportOn` `[id, fingerprint, values]`: the stored value of each `reportOn` field. */
 export type SeenEntry = [string, string] | [string, string, Record<string, string>]
 
+/**
+ * What the herd needs of a ticket: its checked URL, its status, and the epoch milliseconds the watcher recorded
+ * its last reported change at, null when none was reported since it was first seen.
+ */
+export type TicketRecord = { url: string | null; status: string | null; changedAt: number | null }
+
 /**
  * What the watcher keeps per source: `seen` holds a `SeenEntry` per id, the entries seen most recently last, or null
  * before the first successful run (which is a baseline); `failingSince` is the epoch milliseconds of the first failed
  * run of the current streak, null while the source answers. Of an entry's text only the `reportOn` fields are kept.
  */
-export type SourceRecord = { seen: SeenEntry[] | null; failingSince: number | null }
+export type SourceRecord = {
+  seen: SeenEntry[] | null
+  failingSince: number | null
+  /** Of a ticket source only: the entries of its last successful run by id. */
+  tickets?: Record<string, TicketRecord>
+}
 
 export type SourceState = Record<string, SourceRecord>
 
@@ -104,7 +123,7 @@ export type SourceOverflowEvent = { kind: typeof SOURCE_EVENT; name: string; lan
 
 export type SourceEvent = SourceItemEvent | SourceFailureEvent | SourceOverflowEvent
 
-const SEEN_LIMIT = 1000
+export const SEEN_LIMIT = 1000
 const FINGERPRINT_LENGTH = 16
 const STORED_VALUE_LENGTH = 200
 const STORED_PREFIX_LENGTH = 180
@@ -124,7 +143,7 @@ const scalarText = (value: unknown): string | null => {
 export const textAt = (entry: unknown, path: SourcePath | undefined): string | null =>
   path === undefined ? null : scalarText(selectPath(entry, path))
 
-type MappedFields = Omit<SourceItem, 'fingerprint' | 'values'>
+type MappedFields = Omit<SourceItem, 'fingerprint' | 'values' | 'status'>
 
 const hashOf = (text: string, length: number): string =>
   createHash('sha256').update(text).digest('hex').slice(0, length)
@@ -135,15 +154,14 @@ export const storedValue = (text: string): string =>
     ? text
     : `${text.slice(0, STORED_PREFIX_LENGTH)}…${hashOf(text, VALUE_HASH_LENGTH)}`
 
-const hasContentField = (map: SourceMap): boolean =>
-  [map.title, map.author, map.body, map.url].some((path) => path !== undefined)
+const hasContentField = (map: SourceMap): boolean => CONTENT_FIELDS.some((field) => map[field] !== undefined)
 
 /**
  * A short hash of what a reader sees of an entry: title, author, body and URL, so a change of the time alone (a label,
  * a status) is no change. Without any of them mapped it is `updatedAt`, else the entry could never change.
  */
 const contentFingerprint = (fields: MappedFields, map: SourceMap): string => {
-  const content = hasContentField(map) ? [fields.title, fields.author, fields.body, fields.url] : [fields.updatedAt]
+  const content = hasContentField(map) ? CONTENT_FIELDS.map((field) => fields[field]) : [fields.updatedAt]
   return hashOf(JSON.stringify(content), FINGERPRINT_LENGTH)
 }
 
@@ -168,11 +186,14 @@ const valuesOf = (
     ]),
   )
 
-/** One entry after `map`, or null when its id or updatedAt is missing or no text. */
+const statusOf = (entry: unknown, map: SourceMap): string | null =>
+  storedValue(lineText(textAt(entry, map.status) ?? '')) || null
+
+/** One entry after `map`, or null when its id, or a mapped updatedAt, is missing or no text; unmapped it is `''`. */
 const sourceItemOf = (entry: unknown, settings: Pick<SourceSettings, 'map' | 'reportOn'>): SourceItem | null => {
   const { map } = settings
   const id = textAt(entry, map.id)
-  const updatedAt = textAt(entry, map.updatedAt)
+  const updatedAt = map.updatedAt === undefined ? '' : textAt(entry, map.updatedAt)
   if (id === null || id === '' || updatedAt === null) return null
   const url = textAt(entry, map.url)
   const fields = {
@@ -183,7 +204,12 @@ const sourceItemOf = (entry: unknown, settings: Pick<SourceSettings, 'map' | 're
     body: textAt(entry, map.body) ?? '',
     author: textAt(entry, map.author),
   }
-  return { ...fields, fingerprint: contentFingerprint(fields, map), values: valuesOf(entry, fields, settings) }
+  return {
+    ...fields,
+    status: statusOf(entry, map),
+    fingerprint: contentFingerprint(fields, map),
+    values: valuesOf(entry, fields, settings),
+  }
 }
 
 /** The items once each: an id listed twice counts with its last entry. */
@@ -252,13 +278,25 @@ const changeOf = (
   return changes.length === 0 ? null : { change: SOURCE_CHANGE.updated, changes }
 }
 
+/** Whether a run against `seen` reports `item`: new or changed, by an author not ignored. */
+export const reportsItem = (
+  seen: ReadonlyMap<string, SeenEntry>,
+  item: SourceItem,
+  settings: SourceSettings,
+): boolean => changeOf(seen, item, settings) !== null && !isIgnoredAuthor(item, settings.ignoreAuthors)
+
+/** The seen entries of a record by id; null before the first successful run, which is a baseline. */
+export const seenMapOf = (record: SourceRecord | undefined): ReadonlyMap<string, SeenEntry> | null =>
+  record?.seen ? new Map(record.seen.map((entry) => [entry[0], entry])) : null
+
+/** Reports the items `reportsItem` names, with the change; the two must stay one rule, `changedAt` relies on it. */
 const itemEvents = (
   record: SourceRecord | undefined,
   items: readonly SourceItem[],
   settings: SourceSettings,
 ): SourceEvent[] => {
-  if (!record?.seen) return []
-  const seen = new Map(record.seen.map((entry) => [entry[0], entry]))
+  const seen = seenMapOf(record)
+  if (!seen) return []
   const lane = settings.lane ?? null
   const events = items.flatMap((item): SourceItemEvent[] => {
     const found = changeOf(seen, item, settings)
@@ -335,10 +373,19 @@ const isSeenEntry = (value: unknown): boolean =>
   typeof value[1] === 'string' &&
   (value.length === 2 || isStoredValues(value[2]))
 
+const isTextOrNull = (value: unknown): boolean => value === null || typeof value === 'string'
+
+const isTicketRecord = (value: unknown): boolean =>
+  isRecord(value) &&
+  isTextOrNull(value.url) &&
+  isTextOrNull(value.status) &&
+  (value.changedAt === null || typeof value.changedAt === 'number')
+
 const isSourceRecord = (value: unknown): boolean =>
   isRecord(value) &&
   (value.seen === null || (Array.isArray(value.seen) && value.seen.every(isSeenEntry))) &&
-  (value.failingSince === null || typeof value.failingSince === 'number')
+  (value.failingSince === null || typeof value.failingSince === 'number') &&
+  (value.tickets === undefined || (isRecord(value.tickets) && Object.values(value.tickets).every(isTicketRecord)))
 
 export const isSourceState = (value: unknown): value is SourceState =>
   isRecord(value) && Object.values(value).every(isSourceRecord)

package/src/watch/texts.ts

@@ -1,4 +1,4 @@
-import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
+import { APPROVAL_TEXTS, PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
 
 /** The words of the watcher's status and duty lines, in the project's response language. */
 export type WatchTexts = {
@@ -22,12 +22,21 @@ export type WatchTexts = {
   blockedDuty: string
   /** What a lane whose context reached `alert` asks of the coordinator. */
   laneAlertDuty: string
+  /** What a lane whose model fits none of its board row's model column asks of the coordinator. */
+  laneModelDuty: string
+  /** What phases of one lane that can run together ask of the coordinator, with the phases as `P19 ∥ P20`. */
+  parallelDuty: (phases: string) => string
+  /** What a lane's call waiting for approval asks of the coordinator, with the mark (request id and call hash) the question must carry. */
+  approvalDuty: (id: string, hash: string) => string
   /** The reminder after the coordinator line: `<term>: <count> rows only in the checkout`. */
   checkoutRows: (term: string, count: number) => string
   /** The head of the status line of the user's own open pull requests without a lane. */
   otherPullRequests: string
 }
 
+/** The mark the approval gate hook reads from the question, as its `requestMark` writes it (contract test). */
+const approvalMark = (id: string, hash: string): string => `\`approval ${id} ${hash}\``
+
 export const WATCH_TEXTS: Record<PlanLanguage, WatchTexts> = {
   [PLAN_LANGUAGE.de]: {
     noBranch: 'kein Branch',
@@ -48,6 +57,11 @@ export const WATCH_TEXTS: Record<PlanLanguage, WatchTexts> = {
     blockedDuty:
       'Frage gegen Plan und Regeln prüfen, in der Spur beantworten oder per Dialog an den User; nie das Pane weiterreichen',
     laneAlertDuty: 'Übergabe an der nächsten Phasengrenze anfordern (§ 8)',
+    approvalDuty: (id, hash) =>
+      `per AskUserQuestion fragen, die Frage enthält ${approvalMark(id, hash)} (Hash wie in der gezeigten Datei), Optionen „${APPROVAL_TEXTS.de.allow}“ und „${APPROVAL_TEXTS.de.deny}“ (§ 4)`,
+    parallelDuty: (phases) =>
+      `${phases} parallel möglich: dem User vorschlagen, Inhalt und Release-Dateien selbst prüfen (Tabelle prüft nur Pfade und Marker)`,
+    laneModelDuty: 'idle umstellen: /exit, dann claude --resume <session> --model <id> im selben Pane (§ 2 Schritt 6)',
     checkoutRows: (term, count) => `${term}: ${count} ${count === 1 ? 'Zeile' : 'Zeilen'} nur im Checkout`,
     otherPullRequests: 'andere PRs',
   },
@@ -70,6 +84,12 @@ export const WATCH_TEXTS: Record<PlanLanguage, WatchTexts> = {
     blockedDuty:
       'vet the question against the plan and the rules, answer it in the lane or ask the user in a dialog; never hand the pane over',
     laneAlertDuty: 'request the hand-over at the next phase boundary (§ 8)',
+    approvalDuty: (id, hash) =>
+      `ask through AskUserQuestion, the question contains ${approvalMark(id, hash)} (hash as in the file shown), options "${APPROVAL_TEXTS.en.allow}" and "${APPROVAL_TEXTS.en.deny}" (§ 4)`,
+    parallelDuty: (phases) =>
+      `${phases} can run in parallel: propose it to the user, check content and release files yourself (the table covers paths and markers only)`,
+    laneModelDuty:
+      'switch it while idle: /exit, then claude --resume <session> --model <id> in the same pane (§ 2 step 6)',
     checkoutRows: (term, count) => `${term}: ${count} ${count === 1 ? 'row' : 'rows'} only in the checkout`,
     otherPullRequests: 'other PRs',
   },

package/src/watch/watch-defaults.ts

@@ -0,0 +1,8 @@
+/** The comment the CI code review posts when a run found nothing; the default of `watch.feedback.noFindingTemplates`. */
+export const CLEAN_REVIEW_TEXT = '## Code review\n\nNo issues found. Checked for bugs and CLAUDE.md compliance.'
+
+/**
+ * The default of `watch.checks.failedTestPattern`: Bun's `(fail) <name>` line, with the duration ` [1.00ms]` or
+ * ` [1.2s]` after the name left out. The first group is the name.
+ */
+export const BUN_FAILED_TEST_PATTERN = '^\\(fail\\) (.+?)(?: \\[[\\d.]+m?s\\])?$'