jackherd 1.16.0 → 1.18.0

package/src/watch/command.ts

@@ -34,6 +34,7 @@ import { basename, dirname, join, relative } from 'node:path'
 import { writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
 import { sourcesWithPersonal } from '../config/personal-sources'
 import { readConfig, readResolvedConfig } from '../config/read-config'
+import { readRepositoryIdentity } from '../config/repository-identity'
 import type { JackherdConfig } from '../config/schema'
 import { resolveCoordinatorName } from '../context/coordinator-name'
 import { coordinatorSettings } from '../context/options'
@@ -45,12 +46,14 @@ import { boardFor, foundLanesOf } from '../plans/board-pick'
 import { ensurePlanPanes } from '../plans/ensure-panes'
 import { errorText } from '../plans/error-text'
 import { baseReaderOf, mainCheckout, worktreeNames, worktreeRoot } from '../plans/git'
-import { discoverLanes, isUnchanged, laneSetChange, laneSetLines } from '../plans/lane-discovery'
+import { discoverLanes, isUnchanged, laneSetChange } from '../plans/lane-discovery'
 import { readerOncePerRef } from '../plans/plan-heads'
 import { CLOCK_LOCALE, type PlansSettings, plansSettingsOf, worktreeOf } from '../plans/settings'
 import { readRunningSubagents, subagentSourceOf } from '../plans/subagents-read'
 import { boardTexts } from '../plans/texts'
 import { readWaitingRecords, waitingItemsOf } from '../plans/waiting-records'
+import { keepRecord } from '../resume/keeper'
+import { systemRecordStore } from '../resume/ports'
 import { defaultUpdateCheck } from '../sync/if-changed'
 import { DEFAULT_SKILL_PREFIX } from '../sync/init'
 import { herdrLaneStatusSource } from '../terminal/herdr'
@@ -65,6 +68,14 @@ import {
 } from './appointments'
 import { type ApprovalRequestFile, approvalEvents, readApprovalRequests, recordApprovals } from './approvals'
 import { askingLanes, questionsFingerprint, recordReportQuestions } from './asking-lanes'
+import {
+  baselinesOf,
+  type LiveValues,
+  liveValuesOf,
+  nextLoadedConfig,
+  readWatchedConfig,
+  withoutRunsBefore,
+} from './config-reload'
 import {
   type CoordinatorRead,
   contextReadingOf,
@@ -94,7 +105,7 @@ 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 { type LaneModelReading, laneModelEvents, recordLaneModels } from './lane-model'
+import { type LaneModelReading, laneModelEvents, modelColumnOf, recordLaneModels } from './lane-model'
 import { laneParallelEvents, recordLaneParallels } from './lane-parallel'
 import {
   boardCheckoutRows,
@@ -103,6 +114,7 @@ import {
   watchedPlanPullRequests,
   watchedReadyPhases,
   workedPhaseKeys,
+  worktreeOpenBoxes,
 } from './lane-progress'
 import {
   appointmentEventLine,
@@ -119,6 +131,8 @@ import {
   laneStopHeader,
   mergeDutyLines,
   noTaskSignalDutyLines,
+  type OverlapOf,
+  openBoxesDutyLines,
   otherPullRequestsLine,
   parallelDutyLines,
   planMissingDutyLines,
@@ -144,7 +158,8 @@ import {
   NO_AGENT,
   toSnapshot,
 } from './lane-watch'
-import { mainCheckoutDutyLine } from './main-checkout'
+import { isBehindOnBase, mainCheckoutDutyLine } from './main-checkout'
+import { mergeOverlapReader } from './merge-overlap-read'
 import { monitorToolAvailable } from './monitor-tool'
 import { parseWatchOptions, type WatchOptions } from './options'
 import type { PlanMissingEvent, PlanMissingState } from './plan-missing'
@@ -160,6 +175,7 @@ import {
 import { readDeploymentCandidates } from './preview-read'
 import {
   commentCandidates,
+  emptyPreviewState,
   feedbackReadCovers,
   type PreviewRead,
   previewEvents,
@@ -169,27 +185,24 @@ import {
 import { latestPullRequestOf, type WatchedPullRequest } from './pull-requests'
 import { recordedReadsOf } from './recorded-reads'
 import {
+  annotateEach,
   annotateFirstLine,
   eventReference,
+  laneSetEventLines,
   REFERENCE,
   type Reference,
   referenceHint,
   type SkillCopy,
   skillCopiesFor,
   skillDirectoryFor,
+  stageToolsOf,
 } from './reference-paths'
 import { heartbeatNotesOf, runningSubagentCountsOf } from './running-subagents'
 import { withSingleReportNotice } from './single-report'
 import { readOrchestrateSnapshot, skillLineFor } from './skill-change'
 import { runsFromSource, sourceChangeSettled, watchSourceChanges } from './source-change'
 import { sourceDryRun } from './source-dry-run-command'
-import {
-  type LoadedSources,
-  nextLoadedSources,
-  readFileStamps,
-  readWatchedSources,
-  sourceFilePaths,
-} from './source-reload'
+import { type LoadedSources, readFileStamps, sourceFilePaths } from './source-reload'
 import { runSource, SOURCE_LIMITS } from './source-run'
 import { recordedSourceState } from './source-tickets'
 import { isSourceDue, type SourceRun, type SourceState, sourceEvents } from './sources'
@@ -235,15 +248,8 @@ import type { DeployConfig, WorkflowRun } from './workflow-runs'
 
 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']
 type ParallelTasksConfig = JackherdConfig['watch']['parallelTasks']
 
-/** Where deploy previews are read from; undefined when the project reads none. */
-type PreviewsConfig = JackherdConfig['watch']['previews']
-
 /** One feedback read: what counts as feedback, and every item it read, which the previews take their comments from. */
 type FeedbackPoll = { read: FeedbackRead; items: FeedbackItem[] }
 
@@ -256,15 +262,13 @@ type Watch = {
   options: WatchOptions
   files: Files
   settings: PlansSettings
-  deploy: DeployConfig | undefined
-  feedback: FeedbackConfig
-  checks: ChecksConfig
+  /** `watch.deploy`, `feedback`, `previews` and `checks` as read at the start; the loop reads them from `Watching.live`. */
+  live: LiveValues
   parallelTasks: ParallelTasksConfig
   /** `watch.taskSignalMinutes`: how long a lane works without a task signal before `no task signal`. */
   taskSignalMinutes: number
   /** The switch `watch.parallelTasks.auto` and the paths that always ask, both from the main checkout's config. */
   parallelAuto: AutoSettings
-  previews: PreviewsConfig
   /** The sources as read at the start; the loop takes up later changes of their files (`Watching.sources`). */
   sources: LoadedSources
   /** The checkouts whose config the sources are read from, as `readResolvedConfig` takes them. */
@@ -272,6 +276,8 @@ type Watch = {
   texts: WatchTexts
   /** Where the orchestrate skill is installed, the project's copy first; the events name a reference inside the one found. */
   skillCopies: SkillCopy[]
+  /** The tools of `guard.approvals.standing`: an approval of one of them points to the stage approval reference. */
+  stageTools: readonly string[]
   /** Runs inside herdr with the herdr adapter, so missing herd panes can be brought back. */
   herdr: boolean
 }
@@ -316,8 +322,12 @@ type Watching = {
   failureReadings: FailureReading[]
   /** The last preview read that answered; recorded with every state like the feedback read. */
   previewRead: PreviewRead | null
-  /** The sources run now, read again whenever one of their files changes (`nextLoadedSources`). */
+  /** The sources run now, read again whenever one of their files changes (`nextLoadedConfig`). */
   sources: LoadedSources
+  /** The deploy, feedback, previews and checks settings in force now, taken up with the sources. */
+  live: LiveValues
+  /** When a new deploy workflow was taken up, in epoch milliseconds: its runs from before count as the baseline. */
+  deploySince: number | null
   /** The runs of the sources due at the last GitHub poll; recorded with every state like the feedback read. */
   sourceRuns: SourceRun[]
   /** The lanes' fills of the last read; a lane without an entry or with null has no value. */
@@ -347,6 +357,15 @@ type Watching = {
   planViews: PlanViews
 }
 
+/** What the duty lines of one return are made of. */
+type DutyFacts = {
+  stopped: readonly string[]
+  events: readonly WatchEvent[]
+  ready: Readonly<Record<string, ReadyPhase[]>>
+  mainCheckout: string | null
+  overlapOf: OverlapOf | undefined
+}
+
 const POLL_MS = 5_000
 const GITHUB_POLL_MS = 60_000
 const MINUTE_MS = 60_000
@@ -512,28 +531,37 @@ const laneBranchesOf = (watch: Watch, lanes: readonly string[]): Record<string,
 const hintFor = (watch: Watch, reference: Reference | null): string =>
   reference === null ? '' : referenceHint(reference, skillDirectoryFor(watch.skillCopies, existsSync))
 
-/** The lines of one event with its reference hint; a deploy names its target when `watch.deploy` can read it. */
-const linesOfEvent = async (watch: Watch, event: WatchEvent, runs: readonly WorkflowRun[]): Promise<string[]> => {
-  const hint = hintFor(watch, eventReference(event))
+/** The lines of one event with its reference hint; a deploy names its target when `deploy` (`watch.deploy`) can read it. */
+const linesOfEvent = async (
+  watch: Watch,
+  deploy: DeployConfig | undefined,
+  event: WatchEvent,
+  runs: readonly WorkflowRun[],
+): Promise<string[]> => {
+  const hint = hintFor(
+    watch,
+    eventReference(event, (tool) => watch.stageTools.includes(tool)),
+  )
   if (event.kind === WATCH_EVENT.feedback) return annotateFirstLine(feedbackEventLines(event), hint)
   if (event.kind === WATCH_EVENT.source) return annotateFirstLine(sourceEventLines(event), hint)
   if (isAppointmentEvent(event)) return [`${appointmentEventLine(event)}${hint}`]
   const headSha = event.kind === WATCH_EVENT.deploy ? runs.find((run) => run.id === event.runId)?.headSha : undefined
   const target =
-    event.kind === WATCH_EVENT.deploy && headSha && watch.deploy
-      ? await deployTargetOf(watch.root, watch.deploy, event.runId, headSha)
+    event.kind === WATCH_EVENT.deploy && headSha && deploy
+      ? await deployTargetOf(watch.root, deploy, event.runId, headSha)
       : null
   return [`${watchEventLine(event, target ? targetText(target) : null)}${hint}`]
 }
 
 const eventLinesOf = async (
   watch: Watch,
+  deploy: DeployConfig | undefined,
   events: readonly WatchEvent[],
   github: GithubRead | null,
 ): Promise<string[]> => {
   const runs = answered(github)?.runs ?? []
   const lines: string[] = []
-  for (const event of events) lines.push(...(await linesOfEvent(watch, event, runs)))
+  for (const event of events) lines.push(...(await linesOfEvent(watch, deploy, event, runs)))
   return lines
 }
 
@@ -619,7 +647,7 @@ const statusLinesOf = (
     ),
   )
   const outage = state.ghDownSince === null ? [] : [ghUnavailableStatusLine(clock(state.ghDownSince))]
-  const waiting = waitingLineOf(watch)
+  const waiting = waitingLineOf(watch, hintFor(watch, REFERENCE.waiting))
   const board = { term: watch.settings.board.term, checkoutRows }
   const coordinator = coordinatorStatusLine(watching.coordinator.name, watching.coordinator.read, watch.texts, board)
   return {
@@ -644,7 +672,12 @@ const stoppedLaneSections = (
 ): { lines: string[]; reportMtimes: Record<string, number | null> } => {
   const sections = stopped.map((lane) => {
     const status = watching.current[lane]?.status
-    if (!status) return { lane, lines: [`=== ${lane}: ${terminalSafe(LANE_GONE)}`], mtime: undefined }
+    if (!status)
+      return {
+        lane,
+        lines: [`=== ${lane}: ${terminalSafe(LANE_GONE)}${hintFor(watch, REFERENCE.events)}`],
+        mtime: undefined,
+      }
     const message = stopMessageOf(watch, lane, status, next)
     const handoverHint = hasLaneHandover(worktreeOf(watch.root, watch.settings, lane), lane)
       ? hintFor(watch, REFERENCE.laneHandover)
@@ -662,14 +695,21 @@ const stoppedLaneSections = (
 const mainCheckoutLineOf = (watch: Watch): string | null =>
   mainCheckoutDutyLine(readMainCheckout(watch.root, watch.settings.baseBranch), watch.settings.baseBranch, watch.texts)
 
-/** `mainCheckoutLineOf` once a fetch of the base under way has ended when `events` hold a merge, so the merge already counts. */
+/**
+ * The duty line of the main checkout once a fetch of the base under way has ended when `events` hold a merge, so the
+ * merge already counts. While it lags behind, the line names the reference of the board patch that follows a merge.
+ */
 const mainCheckoutLineAfter = async (
   watch: Watch,
   watching: Watching,
   events: readonly WatchEvent[],
 ): Promise<string | null> => {
   if (events.some((event) => event.kind === WATCH_EVENT.merged)) await watching.baseFetch
-  return mainCheckoutLineOf(watch)
+  const read = readMainCheckout(watch.root, watch.settings.baseBranch)
+  const line = mainCheckoutDutyLine(read, watch.settings.baseBranch, watch.texts)
+  return line !== null && isBehindOnBase(read, watch.settings.baseBranch)
+    ? `${line}${hintFor(watch, REFERENCE.events)}`
+    : line
 }
 
 /** The ready phases of the stopped lanes that rest (`done`, `idle`); only their plans are read. */
@@ -685,6 +725,35 @@ const readyPhasesOfResting = (
   return watchedReadyPhases(watch.root, watch.settings, watch.sprintFile, lanes, workedPhaseKeys(progress))
 }
 
+/** The reader of which checks a merge asks of a lane; only a return that holds a merge reads the board for it. */
+const overlapReaderFor = async (watch: Watch, events: readonly WatchEvent[]): Promise<OverlapOf | undefined> => {
+  if (!events.some((event) => event.kind === WATCH_EVENT.merged)) return undefined
+  try {
+    return mergeOverlapReader(watch.root, watch.settings, watch.sprintFile, await Bun.file(watch.sprintFile).text())
+  } catch {
+    return undefined
+  }
+}
+
+/** The duty lines of one return; those that start a lane name `start-lane.md`, a missing plan `plan-commit.md`. */
+const dutyLinesOf = (watch: Watch, watching: Watching, facts: DutyFacts): string[] => {
+  const { stopped, events, ready, mainCheckout, overlapOf } = facts
+  const startLaneHint = hintFor(watch, REFERENCE.startLane)
+  return [
+    ...blockedDutyLines(stopped, watching.current, watch.texts),
+    ...annotateEach(readyPhaseDutyLines(stopped, watching.current, ready, watch.texts), startLaneHint),
+    ...annotateEach(mergeDutyLines(events, watching.lanes, watch.texts, overlapOf), startLaneHint),
+    ...openBoxesDutyLines(events, worktreeOpenBoxes(watch.root, watch.settings), watch.texts),
+    ...(mainCheckout === null ? [] : [mainCheckout]),
+    ...laneFillDutyLines(events, watch.texts),
+    ...laneModelDutyLines(events, watch.texts),
+    ...parallelDutyLines(events, watch.texts),
+    ...noTaskSignalDutyLines(events, watch.texts),
+    ...annotateEach(planMissingDutyLines(events, watch.texts), hintFor(watch, REFERENCE.planCommit)),
+    ...approvalDutyLines(events, watch.texts),
+  ]
+}
+
 /**
  * Every line of one return, gathered before any is printed, so the output is never cut halfway by a slow lookup, and
  * the state with what it showed: the report times of the stopped lanes and the status lines. A state without status
@@ -698,22 +767,12 @@ const reportOf = async (
   next: WatchState,
 ): Promise<{ lines: string[]; next: WatchState }> => {
   const stops = stoppedLaneSections(watch, watching, stopped, next)
-  const eventLines = await eventLinesOf(watch, events, watching.github)
+  const eventLines = await eventLinesOf(watch, watching.live.deploy, events, watching.github)
   const mainCheckout = await mainCheckoutLineAfter(watch, watching, events)
   const board = await boardReadOrNote(watch, watching.lanes, answered(watching.github)?.pullRequests ?? [])
   const ready = readyPhasesOfResting(watch, watching, stopped, board.progress)
-  const dutyLines = [
-    ...blockedDutyLines(stopped, watching.current, watch.texts),
-    ...readyPhaseDutyLines(stopped, watching.current, ready, watch.texts),
-    ...mergeDutyLines(events, watching.lanes, watch.texts),
-    ...(mainCheckout === null ? [] : [mainCheckout]),
-    ...laneFillDutyLines(events, watch.texts),
-    ...laneModelDutyLines(events, watch.texts),
-    ...parallelDutyLines(events, watch.texts),
-    ...noTaskSignalDutyLines(events, watch.texts),
-    ...planMissingDutyLines(events, watch.texts),
-    ...approvalDutyLines(events, watch.texts),
-  ]
+  const overlapOf = await overlapReaderFor(watch, events)
+  const dutyLines = dutyLinesOf(watch, watching, { stopped, events, ready, mainCheckout, overlapOf })
   const status = statusLinesOf(watch, watching, next, board)
   const block = statusBlock(status.laneLines, status.coordinator, next.statusLines, status.others)
   const shownReports = stopped.filter((lane) => stops.reportMtimes[lane] !== next.reportMtimes[lane])
@@ -744,7 +803,7 @@ const recordGithub = (
 
 /**
  * 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
+ * failed run, matched with `watching.live.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 (
@@ -755,7 +814,7 @@ const readFailures = async (
 ): Promise<FailureReading[]> => {
   const answer = answered(github)
   if (!answer) return []
-  const pattern = watch.checks.failedTestPattern
+  const pattern = watching.live.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))),
@@ -773,10 +832,13 @@ 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> =>
+/** Lane → the model column of the row of its current phase; none when the board cannot be read, so no lane reports. */
+const laneModelColumns = (watch: Watch, progress: Readonly<Record<string, LaneProgress>>): Record<string, string> =>
   Object.fromEntries(
-    (readSprintLanes(watch) ?? []).flatMap((lane) => lane.steps.slice(-1).map((step) => [lane.name, step.model])),
+    (readSprintLanes(watch) ?? []).flatMap((lane) => {
+      const column = modelColumnOf(lane, progress[lane.name])
+      return column === undefined ? [] : [[lane.name, column]]
+    }),
   )
 
 /** The agent states a lane can be switched in: it ended its turn and waits for no answer. */
@@ -787,8 +849,9 @@ const laneModelReadingsOf = (
   watch: Watch,
   watching: Watching,
   models: Record<string, string | null>,
+  progress: Readonly<Record<string, LaneProgress>>,
 ): Record<string, LaneModelReading> => {
-  const columns = laneModelColumns(watch)
+  const columns = laneModelColumns(watch, progress)
   return Object.fromEntries(
     Object.entries(models).flatMap(([lane, model]) => {
       const column = columns[lane]
@@ -833,12 +896,13 @@ const readFeedback = async (
   targets: FeedbackTarget[],
   now: number,
 ): Promise<FeedbackPoll | null> => {
-  if (watch.feedback === false || targets.length === 0) return null
+  const { feedback, previews } = watching.live
+  if (feedback === false || targets.length === 0) return null
   const own = await ensureOwnLogin(watch, watching)
   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, watch.previews?.authors ?? [])
+  const filter = feedbackFilterOf(own, feedback, previews?.authors ?? [])
   return { read: feedbackReadOf(now, targets, items.items, filter), items: items.items }
 }
 
@@ -854,11 +918,12 @@ const recordFeedbackRead = (watching: Watching, read: FeedbackRead | null): Watc
  */
 const previewComments = async (
   watch: Watch,
+  previews: LiveValues['previews'],
   state: WatchState,
   feedbackItems: FeedbackItem[] | null,
   now: number,
 ): Promise<FeedbackItemsRead> => {
-  if (!watch.previews || watch.previews.authors.length === 0) return { ok: true, items: [] }
+  if (!previews || previews.authors.length === 0) return { ok: true, items: [] }
   if (feedbackItems && feedbackReadCovers(state.feedback.since, state.previews.since))
     return { ok: true, items: feedbackItems }
   return readCommentItems(watch.root, feedbackSince(state.previews, now))
@@ -876,12 +941,12 @@ const readPreviews = async (
   feedbackItems: FeedbackItem[] | null,
   now: number,
 ): Promise<PreviewRead | null> => {
-  const previews = watch.previews
+  const { previews, deploy } = watching.live
   if (!previews || targets.length === 0) return null
   const unreported = previews.deployments ? unreportedTargets(watching.state.previews, targets) : []
   const [comments, deployments] = await Promise.all([
-    previewComments(watch, watching.state, feedbackItems, now),
-    readDeploymentCandidates(watch.root, unreported, watch.deploy?.environments ?? []),
+    previewComments(watch, previews, watching.state, feedbackItems, now),
+    readDeploymentCandidates(watch.root, unreported, deploy?.environments ?? []),
   ])
   if (!comments.ok || !deployments.ok) return null
   const candidates = [...commentCandidates(comments.items, previews), ...deployments.candidates]
@@ -907,16 +972,28 @@ const runDueSources = (watch: Watch, watching: Watching, now: number): Promise<S
 }
 
 /**
- * Takes up a change of the files the sources come from before the due ones run (`nextLoadedSources`): a source read
- * anew has no `ranAt` and runs at once, its first run a baseline; an invalid file keeps the list and is said once.
+ * Takes up a change of the files the config comes from before the GitHub reads and the due sources run
+ * (`nextLoadedConfig`): the sources and the deploy, feedback, previews and checks settings, read once. A source read
+ * anew has no `ranAt` and runs at once, its first run a baseline; an invalid file keeps everything and is said once.
+ * A new deploy workflow and previews switched on start counting from now (`baselinesOf`).
  */
-const reloadSources = (watch: Watch, watching: Watching) => {
+const reloadConfig = (watch: Watch, watching: Watching) => {
   const stamps = readFileStamps(Object.keys(watching.sources.stamps))
-  const next = nextLoadedSources(watching.sources, stamps, () => readWatchedSources(watch.configRoots, homedir()))
-  watching.sources = next.loaded
+  const next = nextLoadedConfig({ sources: watching.sources, live: watching.live }, stamps, () =>
+    readWatchedConfig(watch.configRoots, homedir()),
+  )
+  const baselines = baselinesOf(watching.live, next.loaded.live)
+  watching.sources = next.loaded.sources
+  watching.live = next.loaded.live
+  if (baselines.deploy) watching.deploySince = Date.now()
+  if (baselines.previews) watching.state = { ...watching.state, previews: emptyPreviewState() }
   for (const line of next.lines) console.log(line)
 }
 
+/** The GitHub read without the deploy runs from before a newly taken up deploy workflow. */
+const withDeployBaseline = (github: GithubRead, since: number | null): GithubRead =>
+  github.ok ? { ...github, runs: withoutRunsBefore(github.runs, since) } : github
+
 const recordSourceRuns = (watching: Watching, runs: SourceRun[]): WatchEvent[] => {
   watching.sourceRuns = runs
   return sourceEvents(watching.state.sources, runs, watching.sources.sources)
@@ -941,8 +1018,8 @@ const syncPlanHeads = (watch: Watch, watching: Watching, pullRequests: readonly
 
 /**
  * Reads the coordinator's fill, GitHub, the feedback, the previews and the due sources, and stores them only once every read is complete: a SIGTERM
- * while a read is pending saves the state as it was, so no event is taken as reported. Before the sources run, a
- * change of the files they come from is taken up (`reloadSources`), which prints its notes.
+ * while a read is pending saves the state as it was, so no event is taken as reported. Before the reads, a
+ * change of the files the config comes from is taken up (`reloadConfig`), which prints its notes.
  */
 const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: number): Promise<WatchEvent[]> => {
   syncBase(watch, watching)
@@ -950,11 +1027,12 @@ const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: n
   const fills = fillReadFor(watch, name, watching.agents, watching.lanes)
   const laneBranches = laneBranchesOf(watch, watching.lanes)
   const searched = Object.values({ ...watching.state.laneBranches, ...laneBranches })
-  reloadSources(watch, watching)
-  const [github, sourceRuns] = await Promise.all([
-    readGithub(watch.root, watch.deploy, watch.settings.baseBranch, searched),
+  reloadConfig(watch, watching)
+  const [read, sourceRuns] = await Promise.all([
+    readGithub(watch.root, watching.live.deploy, watch.settings.baseBranch, searched),
     runDueSources(watch, watching, now),
   ])
+  const github = withDeployBaseline(read, watching.deploySince)
   const pullRequests = answered(github)?.pullRequests ?? null
   syncPlanHeads(watch, watching, pullRequests ?? [])
   const branches = { ...watching.state.laneBranches, ...laneBranches }
@@ -962,6 +1040,7 @@ const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: n
   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
+  const { progress: modelProgress } = await boardReadOrNote(watch, Object.keys(fills.models), pullRequests ?? [])
   return [
     ...recordGithub(watching, github, laneBranches, now, failureReadings),
     ...recordFeedbackRead(watching, feedback?.read ?? null),
@@ -969,7 +1048,7 @@ const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: n
     ...recordSourceRuns(watching, sourceRuns),
     ...recordCoordinator(watching, { name, read: fills.coordinator }),
     ...recordLaneFills(watching, fills.lanes),
-    ...recordLaneModelReads(watching, laneModelReadingsOf(watch, watching, fills.models)),
+    ...recordLaneModelReads(watching, laneModelReadingsOf(watch, watching, fills.models, modelProgress)),
     ...recordLaneParallelReads(watching, laneParallelReadingsOf(watch, watching)),
   ]
 }
@@ -994,9 +1073,10 @@ const readAppointments = (watch: Watch, now: number): Watching['appointments'] =
 }
 
 /** The line of what waits on the user's answer, from the board's own section; null when nothing is open or the board cannot be read. */
-const waitingLineOf = (watch: Watch): string | null => {
+const waitingLineOf = (watch: Watch, hint = ''): string | null => {
   return waitingLine(
     waitingItemsOf(readBoardText(watch), watch.settings.planLanguage, readWaitingRecords(watch.root), Date.now()),
+    hint,
   )
 }
 
@@ -1024,6 +1104,7 @@ const keepViews = (watch: Watch, watching: Watching, trigger: EnsureTrigger) =>
   watching.planViews = keepPlanViews(trigger, watching.planViews, {
     ensure: () => ensurePlanPanes(watch.root, watch.settings, watch.sprintFile),
     log: console.log,
+    failureHint: () => hintFor(watch, REFERENCE.events),
   })
 }
 
@@ -1037,7 +1118,7 @@ const followLaneSet = (watch: Watch, watching: Watching): string[] => {
   watching.departed = [...watching.departed, ...departedLanes(change.removed, watching.baseline, watching.current)]
   watching.lanes = lanes
   watching.current = toSnapshot(watching.agents, lanes)
-  console.log(laneSetLines(change).join('\n'))
+  console.log(laneSetEventLines(change, hintFor(watch, REFERENCE.events)).join('\n'))
   return change.added
 }
 
@@ -1076,7 +1157,10 @@ const report = async (
   watching.reporting = true
   const { lines, next: shown } = await reportOf(watch, watching, stopped, events, next)
   console.log(
-    (watch.options.stream ? lines : withSingleReportNotice(lines, monitorToolAvailable(process.env))).join('\n'),
+    (watch.options.stream
+      ? lines
+      : withSingleReportNotice(lines, monitorToolAvailable(process.env), hintFor(watch, REFERENCE.watchWithoutMonitor))
+    ).join('\n'),
   )
   writePrivateFile(watch.files.state, JSON.stringify(shown))
   watching.reporting = false
@@ -1382,6 +1466,8 @@ const initialWatching = (
   failureReadings: [],
   previewRead: null,
   sources: watch.sources,
+  live: watch.live,
+  deploySince: null,
   sourceRuns: [],
   laneReadings: {},
   laneModelReadings: {},
@@ -1413,12 +1499,20 @@ const watchLanes = async (watch: Watch): Promise<boolean> => {
   const lanes = lanesFor(watch, agents, sprintLanes)
   const armed = toSnapshot(agents, lanes)
   const arm = armNotice(state.armed, lanes, armed, takeOver, relative(watch.root, watch.sprintFile))
-  if (arm.line !== null) console.log(arm.line)
+  if (arm.line !== null)
+    console.log(`${arm.line}${takeOver.stillRunning === null ? '' : hintFor(watch, REFERENCE.events)}`)
   if (watch.boardNotice) console.log(watch.boardNotice)
 
   const watching = initialWatching(watch, { lanes, sprintLanes, state: { ...state, armed: arm.state }, armed, agents })
   keepViews(watch, watching, { kind: ENSURE_TRIGGER.start })
+  const resumeRecord = keepRecord(
+    { root: watch.root, board: watch.sprintFile, coordinator: coordinatorNameFor(watch, agents), pid: process.pid },
+    Date.now(),
+    { store: systemRecordStore(watch.root), log: console.log },
+  )
+  resumeRecord.follow(armed, Date.now())
   process.on('SIGTERM', () => {
+    resumeRecord.stop(Date.now())
     saveState(watch, watching)
     console.log(stopNoticeOf(watch.files.lock))
     process.exit(0)
@@ -1438,16 +1532,23 @@ const watchLanes = async (watch: Watch): Promise<boolean> => {
     : null
   const sourceChanges = kit && runsFromSource(kit.packageRoot) ? watchSourceChanges(kit.packageRoot) : null
   const sourceChanged = () => sourceChangeSettled(sourceChanges?.lastChangeAt() ?? null, Date.now())
-  const effects = { saveState: () => saveState(watch, watching), log: console.log, skillLine, sourceChanged }
+  const effects = {
+    saveState: () => saveState(watch, watching),
+    log: console.log,
+    skillLine,
+    sourceChanged,
+  }
   try {
     while (await pollOnce(watch, watching)) {
       await Bun.sleep(POLL_MS)
       pollLanes(watch, watching)
+      resumeRecord.follow(watching.current, Date.now())
       await announceUpdate?.()
       if (endedByKitUpdate(kit, effects)) return true
     }
     return false
   } finally {
+    resumeRecord.stop(Date.now())
     sourceChanges?.close()
     stopPublisher?.()
   }
@@ -1489,7 +1590,7 @@ const watchOf = (options: WatchOptions): Watch => {
   // Stamped before the read: a change in between is read again at the first poll, never missed.
   const stamps = readFileStamps(sourceFilePaths(configRoots, homedir()))
   const { config, notes } = readResolvedConfig(configRoots)
-  const merged = sourcesWithPersonal(config.watch.sources)
+  const merged = sourcesWithPersonal(config.watch.sources, readRepositoryIdentity(root))
   for (const note of [...notes, ...merged.notes]) console.log(note)
   const settings = plansSettingsOf(config)
   const picked = boardFor(options.boardPath, [root, worktreeRoot(process.cwd())], settings, () =>
@@ -1502,17 +1603,15 @@ const watchOf = (options: WatchOptions): Watch => {
     options,
     files: filesOf(root),
     settings,
-    deploy: config.watch.deploy,
-    feedback: config.watch.feedback,
-    checks: config.watch.checks,
+    live: liveValuesOf(config),
     parallelTasks: config.watch.parallelTasks,
     taskSignalMinutes: config.watch.taskSignalMinutes,
     parallelAuto: autoSettingsOf(root, checkoutRoot, config),
-    previews: config.watch.previews,
     sources: { sources: merged.sources, stamps },
     configRoots,
     texts: watchTexts(settings.responseLanguage),
     skillCopies: skillCopiesFor(root, homedir(), config.skillPrefix, DEFAULT_SKILL_PREFIX),
+    stageTools: stageToolsOf(config.guard.approvals.standing),
     herdr: insideHerdr(settings.adapter, process.env),
   }
 }