jackherd 1.8.1 → 1.10.0

package/src/watch/command.ts

@@ -4,9 +4,11 @@
  * `watch.deploy` in the config), new feedback on a lane's open pull request (unless `watch.feedback` is false), a deploy preview for a
  * lane's new head commit (only with `watch.previews`), a new or changed entry of a configured source or its failure (only
  * with `watch.sources`), a gh outage, a lane's or the coordinator's own context fill rising to warn or alert, or the
- * heartbeat. A blocked lane adds one duty line, a merge one per lane, a lane at alert one, and every report ends with one status line
+ * heartbeat. A blocked lane adds one duty line, a merge one per lane, a lane at alert one, the main checkout behind
+ * `origin/<base>` one in every report and heartbeat until it caught up, and every report ends with one status line
  * per lane and one for the coordinator, in English. When the installed kit changes version
- * it prints `=== kit updated <old> → <new>` and ends; once a day it asks npm and prints `=== update available <old> → <new>`
+ * it prints `=== kit updated <old> → <new>` and ends, and so does a watcher that runs from a checkout's source when
+ * that source changes (`… (source changed)`, the version kept); once a day it asks npm and prints `=== update available <old> → <new>`
  * for a newer release, once per version. The coordinator is the agent in the
  * watcher's own herdr pane unless `--coordinator` names it, else `jack-<repository>` (or the old `orchestrator-<repository>`). A new start replaces a running watcher of the same
  * repository; one in another repository keeps running.
@@ -26,10 +28,11 @@
  *   jh watch [--stream] [--heartbeat <minutes>] [--board <board.md>] [--coordinator <name>] [<lane> ...]
  *   jh watch source <name|draft.json|-> --dry-run
  */
-import { readFileSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, dirname, join, relative } from 'node:path'
-import { readResolvedConfig } from '../config/read-config'
+import { writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
+import { readConfig, readResolvedConfig } from '../config/read-config'
 import type { JackherdConfig } from '../config/schema'
 import { resolveCoordinatorName } from '../context/coordinator-name'
 import { coordinatorSettings } from '../context/options'
@@ -40,11 +43,15 @@ import { terminalSafe } from '../plan-format/terminal-text'
 import { boardFor, foundLanesOf } from '../plans/board-pick'
 import { ensurePlanPanes } from '../plans/ensure-panes'
 import { errorText } from '../plans/error-text'
-import { mainCheckout, worktreeNames, worktreeRoot } from '../plans/git'
+import { baseReaderOf, mainCheckout, worktreeNames, worktreeRoot } from '../plans/git'
 import { discoverLanes, isUnchanged, laneSetChange, laneSetLines } 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 { defaultUpdateCheck } from '../sync/if-changed'
+import { DEFAULT_SKILL_PREFIX } from '../sync/init'
 import { herdrLaneStatusSource } from '../terminal/herdr'
 import { AGENT_STATUS } from '../terminal/types'
 import { startedKit } from '../version/started-kit'
@@ -56,6 +63,7 @@ import {
   recordAppointments,
 } from './appointments'
 import { type ApprovalRequestFile, approvalEvents, readApprovalRequests, recordApprovals } from './approvals'
+import { askingLanes, questionsFingerprint, recordReportQuestions } from './asking-lanes'
 import {
   type CoordinatorRead,
   contextReadingOf,
@@ -79,14 +87,14 @@ import {
 import { type FeedbackItem } from './feedback-item'
 import { type FeedbackItemsRead, readCommentItems, readFeedbackItems, readOwnLogin } from './feedback-read'
 import { answered, deployTargetOf, type GithubRead, readGithub, targetText } from './github-read'
-import { currentPhaseCountsOf, type PhaseCount, progressNotes } from './heartbeat-progress'
+import { currentPhaseCountsOf } from './heartbeat-progress'
 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 { laneParallelEvents, recordLaneParallels } from './lane-parallel'
-import { boardCheckoutRows, watchedLaneParallel, watchedLaneProgress } from './lane-progress'
+import { boardCheckoutRows, watchedLaneParallel, watchedLaneProgress, watchedPlanPullRequests } from './lane-progress'
 import {
   appointmentEventLine,
   approvalDutyLines,
@@ -99,15 +107,18 @@ import {
   laneFillDutyLines,
   laneModelDutyLines,
   laneReportLine,
+  laneStopHeader,
   mergeDutyLines,
+  noTaskSignalDutyLines,
   otherPullRequestsLine,
   parallelDutyLines,
   sourceEventLines,
   sourceFailingStatusLine,
   watchEventLine,
 } from './lane-report'
-import { laneReportPath, readLaneReport, reportMtime } from './lane-report-file'
-import { branchOf, fetchBaseWhenMoved } from './lane-sources'
+import { hasLaneHandover, laneReportPath, readLaneReport, reportMtime } from './lane-report-file'
+import { restNote } from './lane-rest'
+import { branchOf, fetchBaseWhenMoved, fetchPlanHeadsWhenMoved, readMainCheckout } from './lane-sources'
 import {
   advanceBaseline,
   armBaseline,
@@ -120,6 +131,7 @@ import {
   NO_AGENT,
   toSnapshot,
 } from './lane-watch'
+import { mainCheckoutDutyLine } from './main-checkout'
 import { monitorToolAvailable } from './monitor-tool'
 import { parseWatchOptions, type WatchOptions } from './options'
 import {
@@ -141,15 +153,40 @@ import {
 } from './previews'
 import { latestPullRequestOf, type WatchedPullRequest } from './pull-requests'
 import { recordedReadsOf } from './recorded-reads'
+import {
+  annotateFirstLine,
+  eventReference,
+  REFERENCE,
+  type Reference,
+  referenceHint,
+  type SkillCopy,
+  skillCopiesFor,
+  skillDirectoryFor,
+} from './reference-paths'
+import { heartbeatNotesOf, runningSubagentCountsOf } from './running-subagents'
 import { withSingleReportNotice } from './single-report'
-import { readOrchestrateSkill, skillLineFor } from './skill-change'
+import { readOrchestrateSnapshot, skillLineFor } from './skill-change'
+import { runsFromSource, sourceChangeSettled, watchSourceChanges } from './source-change'
 import { sourceDryRun } from './source-dry-run-command'
 import { runSource, SOURCE_LIMITS } from './source-run'
 import { recordWatchedSources } from './source-tickets'
 import { isSourceDue, type SourceRun, type SourceSettings, type SourceState, sourceEvents } from './sources'
 import { streamHeartbeatLine } from './stream-output'
+import {
+  formatTaskParallelLine,
+  TASK_PARALLEL_EVENT,
+  type TaskParallelEvent,
+  type TaskParallelFingerprints,
+  taskParallelReport,
+} from './task-parallel'
+import { AUTO_ASK_PATHS, type AutoSettings, autoEndedReport, autoVerdict, localDay } from './task-parallel-auto'
+import { holdsDataPathIn } from './task-parallel-data-paths'
+import { readTaskParallelInputs } from './task-parallel-read'
+import { type NoSignalState, type NoTaskSignalEvent, noTaskSignalEvents } from './task-signal-missing'
+import { signalledLanes } from './task-signal-read'
 import { type WatchTexts, watchTexts } from './texts'
 import { updateAnnouncer } from './update-available'
+import { waitingLine } from './waiting-line'
 import {
   coordinatorWatchEvent,
   deployEvents,
@@ -163,20 +200,14 @@ import {
   pullRequestEvents,
   recordCoordinatorLevel,
   recordWatchState,
+  UPDATE_AVAILABLE_EVENT,
   WATCH_EVENT,
   type WatchEvent,
   type WatchState,
   withReportBaselines,
 } from './watch-events'
-import {
-  ensureWatcherDirectory,
-  releaseLock,
-  stopNoticeOf,
-  takeOverLock,
-  WATCHER_FILES,
-  writePrivate,
-} from './watcher-lock'
-import type { DeployConfig } from './workflow-runs'
+import { ensureWatcherDirectory, releaseLock, stopNoticeOf, takeOverLock, WATCHER_FILES } from './watcher-lock'
+import type { DeployConfig, WorkflowRun } from './workflow-runs'
 
 type Files = { state: string; lock: string }
 
@@ -184,6 +215,7 @@ type Files = { state: string; lock: string }
 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']
@@ -203,9 +235,16 @@ type Watch = {
   deploy: DeployConfig | undefined
   feedback: FeedbackConfig
   checks: ChecksConfig
+  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
   sources: SourceSettings[]
   texts: WatchTexts
+  /** Where the orchestrate skill is installed, the project's copy first; the events name a reference inside the one found. */
+  skillCopies: SkillCopy[]
   /** Runs inside herdr with the herdr adapter, so missing herd panes can be brought back. */
   herdr: boolean
 }
@@ -230,8 +269,6 @@ type Watching = {
   state: WatchState
   baseline: LaneSnapshot
   current: LaneSnapshot
-  /** The phase count of each lane at the last heartbeat, so a heartbeat names only a count that moved. */
-  heartbeatCounts: Record<string, PhaseCount>
   /** The last `herdr agent list` answer, kept for finding the coordinator by its pane. */
   agents: HerdrAgent[]
   github: GithubRead | null
@@ -240,8 +277,10 @@ type Watching = {
   coordinator: Coordinator
   herdrDown: boolean
   reporting: boolean
-  /** A fetch of the base branch is under way; the next one waits for it. */
-  fetchingBase: boolean
+  /** The fetch of the base branch under way, null when none runs; the next one waits for it, a report after a merge too. */
+  baseFetch: Promise<void> | null
+  /** A fetch of the plan pull request heads is under way; the next one waits for it. */
+  fetchingHeads: boolean
   /** The account `gh` runs as, read once it answers; feedback is read only once it is known. */
   ownLogin: string | null
   /** The last feedback read that answered; its targets and items are recorded with every state. */
@@ -252,18 +291,24 @@ type Watching = {
   previewRead: PreviewRead | null
   /** The runs of the sources due at the last GitHub poll; recorded with every state like the feedback read. */
   sourceRuns: SourceRun[]
-  /** Source name → when it was last started in this process; a source without an entry runs at the next GitHub poll. */
-  sourceRanAt: Record<string, number>
   /** The lanes' fills of the last read; a lane without an entry or with null has no value. */
   laneReadings: LaneReadings
   /** The lanes' models against their board rows at the last read; recorded with every state like the fills. */
   laneModelReadings: Record<string, LaneModelReading>
   /** The phases of each lane's plan that can run together at the last read; recorded with every state like the models. */
   laneParallelReadings: Record<string, string[]>
+  /** The parallel-task fingerprint of each lane at the last heartbeat; persisted like the lane parallels. */
+  taskParallels: TaskParallelFingerprints
+  /** The last day of `watch.parallelTasks.auto` whose end was reported; persisted like the fingerprints. */
+  parallelAutoEnded: string | null
+  /** Since when each lane works without a task signal and the phase last reported; persisted like the fingerprints. */
+  noTaskSignals: NoSignalState
   /** The approval requests of the last poll; null before the first read, so the stored ids stay. */
   approvalRequests: ApprovalRequestFile[] | null
   /** The board's appointment table at the last poll and the time it was read at; null before the first read and while the board cannot be read. */
   appointments: { table: AppointmentTable; readAt: number } | null
+  /** The questions of each watched lane's report at the last poll (`questionsFingerprint`); null before the first read, so the stored ones stay. */
+  reportQuestions: Record<string, string> | null
   planViews: PlanViews
 }
 
@@ -282,6 +327,14 @@ const observationOf = (watching: Watching): Observation => ({
   github: answered(watching.github),
 })
 
+/** The report questions to remember with the lanes whose report was `shown`; before the first read, the stored ones. */
+const reportQuestionsAfter = (
+  watching: Watching,
+  remembered: Record<string, string>,
+  shown: readonly string[],
+): Record<string, string> =>
+  watching.reportQuestions === null ? remembered : recordReportQuestions(remembered, watching.reportQuestions, shown)
+
 /** Stamped with the time of the last GitHub read, not of the poll: a run created after it is still unseen. */
 const recordedOf = (watch: Watch, watching: Watching): WatchState => {
   const recorded = recordCoordinatorLevel(
@@ -299,11 +352,15 @@ const recordedOf = (watch: Watch, watching: Watching): WatchState => {
     laneLevels: recordLaneLevels(withReads.laneLevels, watching.laneReadings, watching.lanes),
     laneModels: recordLaneModels(withReads.laneModels, watching.laneModelReadings, watching.lanes),
     laneParallels: recordLaneParallels(withReads.laneParallels, watching.laneParallelReadings, watching.lanes),
+    taskParallels: watching.taskParallels,
+    parallelAutoEnded: watching.parallelAutoEnded,
+    noTaskSignals: watching.noTaskSignals,
     approvals: watching.approvalRequests ? recordApprovals(watching.approvalRequests) : withReads.approvals,
     sources: recordWatchedSources(withReads.sources, watching.sourceRuns, watch.sources, watching.githubReadAt),
     appointments: watching.appointments
       ? recordAppointments(withReads.appointments, watching.appointments.table, watching.appointments.readAt)
       : withReads.appointments,
+    reportQuestions: reportQuestionsAfter(watching, withReads.reportQuestions, []),
   }
   return withReportBaselines(withLevels, watching.lanes, (lane) => reportMtime(reportPathOf(watch, lane)))
 }
@@ -340,6 +397,18 @@ const screenOf = (lane: string): string => {
 const reportPathOf = (watch: Watch, lane: string): string | null =>
   laneReportPath(worktreeOf(watch.root, watch.settings, lane), lane)
 
+/** What a resting lane waits on, from its report file (`restNote`); null while it works or when it asks nothing. */
+const restNoteOf = (watch: Watch, lane: string, status: string | undefined): string | null =>
+  status !== undefined && IDLE_STATUSES.has(status)
+    ? restNote(readLaneReport(reportPathOf(watch, lane))?.text ?? null)
+    : null
+
+/** The questions of each watched lane's report (`questionsFingerprint`), read at every poll. */
+const readReportQuestions = (watch: Watch, lanes: readonly string[]): Record<string, string> =>
+  Object.fromEntries(
+    lanes.map((lane) => [lane, questionsFingerprint(readLaneReport(reportPathOf(watch, lane))?.text ?? null)]),
+  )
+
 /** The lines under a stopped lane's header and its report time to remember (`laneMessage`). */
 const stopMessageOf = (watch: Watch, lane: string, status: string, state: WatchState) =>
   laneMessage({
@@ -401,6 +470,24 @@ const laneBranchesOf = (watch: Watch, lanes: readonly string[]): Record<string,
     }),
   )
 
+/** ` · read <path>` of `reference` in the skill copy found now; read per line, so a skill installed meanwhile is found. */
+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))
+  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)
+      : null
+  return [`${watchEventLine(event, target ? targetText(target) : null)}${hint}`]
+}
+
 const eventLinesOf = async (
   watch: Watch,
   events: readonly WatchEvent[],
@@ -408,26 +495,7 @@ const eventLinesOf = async (
 ): Promise<string[]> => {
   const runs = answered(github)?.runs ?? []
   const lines: string[] = []
-  for (const event of events) {
-    if (event.kind === WATCH_EVENT.feedback) {
-      lines.push(...feedbackEventLines(event))
-      continue
-    }
-    if (event.kind === WATCH_EVENT.source) {
-      lines.push(...sourceEventLines(event))
-      continue
-    }
-    if (isAppointmentEvent(event)) {
-      lines.push(appointmentEventLine(event))
-      continue
-    }
-    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)
-        : null
-    lines.push(watchEventLine(event, target ? targetText(target) : null))
-  }
+  for (const event of events) lines.push(...(await linesOfEvent(watch, event, runs)))
   return lines
 }
 
@@ -435,22 +503,23 @@ const eventLinesOf = async (
 const boardReadOf = async (
   watch: Watch,
   lanes: readonly string[],
+  pullRequests: readonly WatchedPullRequest[],
 ): Promise<{ progress: Record<string, LaneProgress>; checkoutRows: number }> => {
   const text = await Bun.file(watch.sprintFile).text()
   const sprintLanes = parseSprintLanes(text, watch.settings.planLanguage)
   const watched = sprintLanes.filter((lane) => lanes.includes(lane.name))
-  const entries = await Promise.all(
-    watched.map(
-      async (lane) =>
-        [lane.name, await watchedLaneProgress(watch.root, watch.settings, watch.sprintFile, lane)] as const,
-    ),
-  )
+  const planPulls = watchedPlanPullRequests(pullRequests, watch.settings)
+  const headReaderOf = readerOncePerRef((ref) => baseReaderOf(watch.root, ref))
+  const progressOf = (lane: SprintLane) =>
+    watchedLaneProgress(watch.root, watch.settings, watch.sprintFile, lane, planPulls, headReaderOf)
+  const entries = await Promise.all(watched.map(async (lane) => [lane.name, await progressOf(lane)] as const))
   const checkoutRows = boardCheckoutRows(watch.root, watch.settings, watch.sprintFile, text)
   return { progress: Object.fromEntries(entries), checkoutRows }
 }
 
 /** What the status line of one lane is made of, from the loop's state. */
 const laneReportOf = (
+  watch: Watch,
   lane: string,
   watching: Watching,
   state: WatchState,
@@ -467,6 +536,7 @@ const laneReportOf = (
     pullRequest: pullRequest ? { number: pullRequest.number, checks: pullRequest.checks, feedback } : null,
     progress,
     context: watching.laneReadings[lane]?.level ?? null,
+    rest: restNoteOf(watch, lane, watching.current[lane]?.status),
   }
 }
 
@@ -474,9 +544,10 @@ const laneReportOf = (
 const boardReadOrNote = async (
   watch: Watch,
   lanes: readonly string[],
+  pullRequests: readonly WatchedPullRequest[],
 ): Promise<{ progress: Record<string, LaneProgress>; checkoutRows: number; notes: string[] }> => {
   try {
-    return { ...(await boardReadOf(watch, lanes)), notes: [] }
+    return { ...(await boardReadOf(watch, lanes, pullRequests)), notes: [] }
   } catch (error) {
     return {
       progress: {},
@@ -498,18 +569,24 @@ const statusLinesOf = async (
   const github = answered(watching.github)
   const pullRequests = github?.pullRequests ?? []
   const others = otherPullRequestsLine(pullRequests, github?.own ?? [], watch.texts)
-  const { progress, checkoutRows, notes } = await boardReadOrNote(watch, watching.lanes)
+  const { progress, checkoutRows, notes } = await boardReadOrNote(watch, watching.lanes, pullRequests)
+  const closeLaneHint = hintFor(watch, REFERENCE.closeLane)
   const laneLines = watching.lanes.map((lane) =>
-    laneReportLine(laneReportOf(lane, watching, state, pullRequests, progress[lane] ?? null), watch.texts),
+    laneReportLine(
+      laneReportOf(watch, lane, watching, state, pullRequests, progress[lane] ?? null),
+      watch.texts,
+      closeLaneHint,
+    ),
   )
   const outage = state.ghDownSince === null ? [] : [ghUnavailableStatusLine(clock(state.ghDownSince))]
+  const waiting = waitingLineOf(watch)
   const board = { term: watch.settings.board.term, checkoutRows }
   const coordinator = coordinatorStatusLine(watching.coordinator.name, watching.coordinator.read, watch.texts, board)
   return {
     laneLines,
     coordinator,
     others: others === null ? [] : [others],
-    rest: [...notes, ...outage, ...failingSourceLines(state.sources)],
+    rest: [...notes, ...(waiting === null ? [] : [waiting]), ...outage, ...failingSourceLines(state.sources)],
   }
 }
 
@@ -529,7 +606,10 @@ const stoppedLaneSections = (
     const status = watching.current[lane]?.status
     if (!status) return { lane, lines: [`=== ${lane}: ${terminalSafe(LANE_GONE)}`], mtime: undefined }
     const message = stopMessageOf(watch, lane, status, next)
-    return { lane, lines: [`=== ${lane}: ${terminalSafe(status)}`, ...message.lines], mtime: message.reportedMtime }
+    const handoverHint = hasLaneHandover(worktreeOf(watch.root, watch.settings, lane), lane)
+      ? hintFor(watch, REFERENCE.laneHandover)
+      : null
+    return { lane, lines: [laneStopHeader(lane, status, handoverHint), ...message.lines], mtime: message.reportedMtime }
   })
   const shown = sections.flatMap(({ lane, mtime }) => (mtime === undefined ? [] : [[lane, mtime] as const]))
   return {
@@ -538,6 +618,20 @@ const stoppedLaneSections = (
   }
 }
 
+/** The duty line while the main checkout lags behind `origin/<base>`, read from the local refs; null when caught up. */
+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. */
+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)
+}
+
 /**
  * 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
@@ -552,21 +646,26 @@ const reportOf = async (
 ): Promise<{ lines: string[]; next: WatchState }> => {
   const stops = stoppedLaneSections(watch, watching, stopped, next)
   const eventLines = await eventLinesOf(watch, events, watching.github)
+  const mainCheckout = await mainCheckoutLineAfter(watch, watching, events)
   const dutyLines = [
     ...blockedDutyLines(stopped, watching.current, 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),
     ...approvalDutyLines(events, watch.texts),
   ]
   const status = await statusLinesOf(watch, watching, next)
   const block = statusBlock(status.laneLines, status.coordinator, next.statusLines, status.others)
+  const shownReports = stopped.filter((lane) => stops.reportMtimes[lane] !== next.reportMtimes[lane])
   return {
     lines: [...stops.lines, ...eventLines, ...dutyLines, ...block, ...status.rest],
     next: {
       ...next,
       reportMtimes: stops.reportMtimes,
+      reportQuestions: reportQuestionsAfter(watching, next.reportQuestions, shownReports),
       statusLines: rememberedStatusLines(status.laneLines, status.others),
     },
   }
@@ -739,12 +838,14 @@ const recordPreviewRead = (watching: Watching, read: PreviewRead | null): WatchE
 }
 
 /**
- * Runs the sources whose interval has passed, all at once, each without a shell and within `SOURCE_LIMITS`; a failed
- * run is a result, never a throw, so no source stops the watcher.
+ * Runs the sources whose interval has passed since the start the saved state holds (`ranAt`, so a restart runs none
+ * early), all at once, each without a shell and within `SOURCE_LIMITS`; a failed run is a result, never a throw, so no
+ * source stops the watcher. The run's start is recorded with the GitHub read's time, which is `now`.
  */
 const runDueSources = (watch: Watch, watching: Watching, now: number): Promise<SourceRun[]> => {
-  const due = watch.sources.filter((source) => isSourceDue(watching.sourceRanAt[source.name], source.every, now))
-  for (const source of due) watching.sourceRanAt[source.name] = now
+  const due = watch.sources.filter((source) =>
+    isSourceDue(watching.state.sources[source.name]?.ranAt, source.every, now),
+  )
   return Promise.all(due.map((source) => runSource(source, watch.root, SOURCE_LIMITS)))
 }
 
@@ -755,10 +856,18 @@ const recordSourceRuns = (watch: Watch, watching: Watching, runs: SourceRun[]):
 
 /** Starts a fetch of the base branch in the background when none runs; the loop does not wait for it. */
 const syncBase = (watch: Watch, watching: Watching) => {
-  if (watching.fetchingBase) return
-  watching.fetchingBase = true
-  void fetchBaseWhenMoved(watch.root, watch.settings.baseBranch).finally(() => {
-    watching.fetchingBase = false
+  if (watching.baseFetch) return
+  watching.baseFetch = fetchBaseWhenMoved(watch.root, watch.settings.baseBranch).finally(() => {
+    watching.baseFetch = null
+  })
+}
+
+/** Starts a fetch of the moved plan pull request heads in the background when none runs, like `syncBase`. */
+const syncPlanHeads = (watch: Watch, watching: Watching, pullRequests: readonly WatchedPullRequest[]) => {
+  if (watching.fetchingHeads) return
+  watching.fetchingHeads = true
+  void fetchPlanHeadsWhenMoved(watch.root, watchedPlanPullRequests(pullRequests, watch.settings)).finally(() => {
+    watching.fetchingHeads = false
   })
 }
 
@@ -777,6 +886,7 @@ const pollGithubAndCoordinator = async (watch: Watch, watching: Watching, now: n
     runDueSources(watch, watching, now),
   ])
   const pullRequests = answered(github)?.pullRequests ?? null
+  syncPlanHeads(watch, watching, pullRequests ?? [])
   const branches = { ...watching.state.laneBranches, ...laneBranches }
   const failureReadings = await readFailures(watch, watching, github, branches)
   const targets = feedbackTargets(pullRequests, branches, watching.state.feedback)
@@ -813,6 +923,13 @@ const readAppointments = (watch: Watch, now: number): Watching['appointments'] =
   return { table: readAppointmentTable(board, watch.settings.planLanguage, new Date(now)), readAt: now }
 }
 
+/** 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 => {
+  return waitingLine(
+    waitingItemsOf(readBoardText(watch), watch.settings.planLanguage, readWaitingRecords(watch.root), Date.now()),
+  )
+}
+
 /** The board's lanes, null when the board cannot be read. */
 const readSprintLanes = (watch: Watch): SprintLane[] | null => {
   const board = readBoardText(watch)
@@ -891,23 +1008,169 @@ const report = async (
   console.log(
     (watch.options.stream ? lines : withSingleReportNotice(lines, monitorToolAvailable(process.env))).join('\n'),
   )
-  writePrivate(watch.files.state, JSON.stringify(shown))
+  writePrivateFile(watch.files.state, JSON.stringify(shown))
   watching.reporting = false
   return shown
 }
 
 /**
- * The heartbeat of a stream: one line, a working lane with its phase count when that moved since the last heartbeat.
- * The plans are read only when a lane works; a board that cannot be read leaves the lines without a count, and the
- * next report names the failure.
+ * The parallel-task proposals of this heartbeat, one event per open lane whose situation changed since the last
+ * heartbeat and that has a proposal, marked by `autoVerdict` against the switch, and the fingerprints of every lane
+ * read, kept for the next one. Nothing when herdr or the board cannot be read: a proposal is a hint, and the next
+ * heartbeat reads again.
+ */
+const taskParallelProposalsOf = (
+  watch: Watch,
+  watching: Watching,
+  now: number,
+): { events: TaskParallelEvent[]; fingerprints: TaskParallelFingerprints } => {
+  try {
+    const lanes = (readSprintLanes(watch) ?? []).filter((lane) => !lane.closed && watching.lanes.includes(lane.name))
+    const inputs = readTaskParallelInputs(lanes, herdrLaneStatusSource.listAgents(), {
+      root: watch.root,
+      settings: watch.settings,
+      boardFile: watch.sprintFile,
+      thresholdTokens: watch.parallelTasks.maxTokens,
+      now,
+    })
+    const reports = Object.entries(inputs).map(
+      ([lane, input]) => [lane, input, taskParallelReport(watching.taskParallels[lane], input)] as const,
+    )
+    const today = localDay(now)
+    return {
+      events: reports.flatMap(([lane, input, { proposal }]) =>
+        proposal
+          ? [
+              {
+                kind: TASK_PARALLEL_EVENT,
+                lane,
+                line: formatTaskParallelLine(lane, proposal, autoVerdict(input, proposal, watch.parallelAuto, today)),
+              },
+            ]
+          : [],
+      ),
+      fingerprints: Object.fromEntries(reports.map(([lane, , { fingerprint }]) => [lane, fingerprint])),
+    }
+  } catch {
+    return { events: [], fingerprints: {} }
+  }
+}
+
+/**
+ * This heartbeat's parallel-task events: the line that `watch.parallelTasks.auto` ended, once per last day, then the
+ * proposals. Records the fingerprints and the reported end in `watching`.
+ */
+const taskParallelEventsOf = (watch: Watch, watching: Watching, now: number): TaskParallelEvent[] => {
+  const { events, fingerprints } = taskParallelProposalsOf(watch, watching, now)
+  const { ended, line } = autoEndedReport(watching.parallelAutoEnded, watch.parallelAuto.auto, localDay(now))
+  watching.taskParallels = { ...watching.taskParallels, ...fingerprints }
+  watching.parallelAutoEnded = ended
+  return line === null ? events : [{ kind: TASK_PARALLEL_EVENT, lane: null, line }, ...events]
+}
+
+const workingLanes = (watching: Watching): string[] =>
+  watching.lanes.filter((lane) => watching.current[lane]?.status === AGENT_STATUS.working)
+
+/**
+ * This heartbeat's `no task signal` events (D112): each watched lane read as working or not, with an open task signal
+ * or not, and its current phase from `progress`; records the clocks in `watching`. Nothing when herdr or the logs
+ * cannot be read: the event is a reminder, and the next heartbeat reads again.
+ */
+const noTaskSignalEventsOf = (
+  watch: Watch,
+  watching: Watching,
+  progress: Readonly<Record<string, LaneProgress>>,
+  now: number,
+): NoTaskSignalEvent[] => {
+  try {
+    const working = new Set(workingLanes(watching))
+    const signalled = signalledLanes(watching.lanes, {
+      root: watch.root,
+      worktreeDirectory: watch.settings.worktreeDirectory,
+      now,
+    })
+    const counts = currentPhaseCountsOf(progress)
+    const readings = Object.fromEntries(
+      watching.lanes.map((lane) => [
+        lane,
+        { working: working.has(lane), signalled: signalled.has(lane), phaseId: counts[lane]?.id ?? null },
+      ]),
+    )
+    const { events, state } = noTaskSignalEvents(watching.noTaskSignals, readings, now, watch.taskSignalMinutes)
+    watching.noTaskSignals = state
+    return events
+  } catch {
+    return []
+  }
+}
+
+/** The progress of the working lanes, with the pull requests of the last GitHub read; nothing while no lane works. */
+const workingProgressOf = async (watch: Watch, watching: Watching): Promise<Record<string, LaneProgress>> => {
+  const working = workingLanes(watching)
+  if (working.length === 0) return {}
+  const { progress } = await boardReadOrNote(watch, working, answered(watching.github)?.pullRequests ?? [])
+  return progress
+}
+
+/** The events a heartbeat of a report brings: the parallel-task proposals, then the lanes without a task signal. */
+const heartbeatEventsOf = async (watch: Watch, watching: Watching, now: number): Promise<WatchEvent[]> => {
+  const progress = await workingProgressOf(watch, watching)
+  return [...taskParallelEventsOf(watch, watching, now), ...noTaskSignalEventsOf(watch, watching, progress, now)]
+}
+
+/**
+ * The subagents running in each worktree, from the chain the herd reads for its own view (`readRunningSubagents`). Nothing
+ * when the logs cannot be read: a note is a hint, and the next heartbeat reads again.
+ */
+const subagentCountsOf = (watch: Watch, now: number): Record<string, number> => {
+  try {
+    const worktreeDirectory = join(watch.root, watch.settings.worktreeDirectory)
+    const running = readRunningSubagents(
+      subagentSourceOf(watch.root, worktreeDirectory, watch.settings.skillPrefix),
+      now,
+    )
+    return runningSubagentCountsOf(running, worktreeDirectory)
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * The heartbeat of a stream: one line, a working lane with its phase count at every heartbeat and the subagents running
+ * in its worktree. The plans are read only when a lane works; a board that cannot be read leaves the lines without a
+ * count, and the next report names the failure.
  */
 const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: number): Promise<void> => {
-  const working = watching.lanes.filter((lane) => watching.current[lane]?.status === AGENT_STATUS.working)
-  const { progress } = working.length > 0 ? await boardReadOrNote(watch, working) : { progress: {} }
+  const working = workingLanes(watching)
+  const progress = await workingProgressOf(watch, watching)
   const counts = currentPhaseCountsOf(progress)
-  const notes = progressNotes(watching.lanes, watching.current, counts, watching.heartbeatCounts)
-  watching.heartbeatCounts = { ...watching.heartbeatCounts, ...counts }
-  console.log(streamHeartbeatLine(clock(now), watching.lanes, watching.current, notes))
+  const notes = heartbeatNotesOf(working, counts, working.length > 0 ? subagentCountsOf(watch, now) : {})
+  const rests = Object.fromEntries(
+    watching.lanes.flatMap((lane) => {
+      const rest = restNoteOf(watch, lane, watching.current[lane]?.status)
+      return rest === null ? [] : [[lane, rest]]
+    }),
+  )
+  const standing = [waitingLineOf(watch), mainCheckoutLineOf(watch)].filter((line) => line !== null)
+  console.log(streamHeartbeatLine(clock(now), watching.lanes, watching.current, notes, rests, standing))
+  const events = [
+    ...taskParallelEventsOf(watch, watching, now),
+    ...noTaskSignalEventsOf(watch, watching, progress, now),
+  ]
+  for (const event of events) console.log(`${watchEventLine(event, null)}${hintFor(watch, eventReference(event))}`)
+}
+
+/**
+ * The lanes to report as stopped: those that stopped or left since the last poll, and the working lanes whose report
+ * asks something new (`askingLanes`): a lane waiting on its background subagents ends no turn. Takes the departed
+ * lanes and records the questions read.
+ */
+const takeStoppedLanes = (watch: Watch, watching: Watching): string[] => {
+  const fired = [...firedLanes(watching.baseline, watching.current, watching.lanes), ...watching.departed]
+  watching.departed = []
+  watching.reportQuestions = readReportQuestions(watch, watching.lanes)
+  const working = workingLanes(watching).filter((lane) => !fired.includes(lane))
+  return [...fired, ...askingLanes(working, watching.reportQuestions, watching.state.reportQuestions)]
 }
 
 /**
@@ -932,8 +1195,7 @@ const pollOnce = async (watch: Watch, watching: Watching): Promise<boolean> => {
     ...approvalEvents(watching.state.approvals, watching.approvalRequests, now),
     ...appointmentEvents(watching.state.appointments, watching.appointments?.table ?? null, now),
   ]
-  const stopped = [...firedLanes(watching.baseline, watching.current, watching.lanes), ...watching.departed]
-  watching.departed = []
+  const stopped = takeStoppedLanes(watch, watching)
   const heartbeat = isHeartbeatDue(watching.quietSince, now, heartbeatMinutes * MINUTE_MS)
   let next = recordedOf(watch, watching)
   const reported = stopped.length > 0 || polledEvents.length > 0
@@ -941,10 +1203,17 @@ const pollOnce = async (watch: Watch, watching: Watching): Promise<boolean> => {
     next = await report(watch, watching, stopped, polledEvents, next)
     watching.baseline = { ...watching.current }
   } else if (heartbeat && !stream) {
-    next = await report(watch, watching, [], [{ kind: WATCH_EVENT.heartbeat }], { ...next, statusLines: null })
+    const proposals = await heartbeatEventsOf(watch, watching, now)
+    next = await report(watch, watching, [], [{ kind: WATCH_EVENT.heartbeat }, ...proposals], {
+      ...recordedOf(watch, watching),
+      statusLines: null,
+    })
   } else {
-    if (heartbeat) await printStreamHeartbeat(watch, watching, now)
-    if (due) writePrivate(watch.files.state, JSON.stringify(next))
+    if (heartbeat) {
+      await printStreamHeartbeat(watch, watching, now)
+      next = recordedOf(watch, watching)
+    }
+    if (due) writePrivateFile(watch.files.state, JSON.stringify(next))
     watching.baseline = advanceBaseline(watching.baseline, watching.current)
   }
   watching.state = next
@@ -968,30 +1237,33 @@ const initialWatching = (
   agents: start.agents,
   github: null,
   laneBranches: {},
-  heartbeatCounts: {},
   githubReadAt: 0,
   coordinator: { name: watch.options.coordinator, read: null },
   herdrDown: false,
   reporting: false,
-  fetchingBase: false,
+  baseFetch: null,
+  fetchingHeads: false,
   ownLogin: null,
   feedbackRead: null,
   failureReadings: [],
   previewRead: null,
   sourceRuns: [],
-  sourceRanAt: {},
   laneReadings: {},
   laneModelReadings: {},
   laneParallelReadings: {},
+  taskParallels: start.state.taskParallels,
+  parallelAutoEnded: start.state.parallelAutoEnded,
+  noTaskSignals: start.state.noTaskSignals,
   approvalRequests: null,
   appointments: null,
+  reportQuestions: null,
   planViews: { failureReported: false },
 })
 
 /** Saves the state a stop leaves behind: the one from before an unfinished report or an unread GitHub answer, else the latest. */
 const saveState = (watch: Watch, watching: Watching) => {
   const unread = watching.reporting || watching.github === null
-  writePrivate(watch.files.state, JSON.stringify(unread ? watching.state : recordedOf(watch, watching)))
+  writePrivateFile(watch.files.state, JSON.stringify(unread ? watching.state : recordedOf(watch, watching)))
 }
 
 const watchLanes = async (watch: Watch) => {
@@ -1013,14 +1285,25 @@ const watchLanes = async (watch: Watch) => {
   })
 
   const kit = await startedKit()
-  const skillSnapshot = kit ? readOrchestrateSkill(kit.packageRoot) : null
+  const skillSnapshot = kit ? readOrchestrateSnapshot(kit.packageRoot) : null
   const skillLine = () => skillLineFor(kit, skillSnapshot, dirname(watch.files.state))
-  const announceUpdate = kit ? updateAnnouncer(homedir(), kit.version, defaultUpdateCheck(), console.log) : null
-  while (await pollOnce(watch, watching)) {
-    await Bun.sleep(POLL_MS)
-    pollLanes(watch, watching)
-    await announceUpdate?.()
-    if (endedByKitUpdate(kit, { saveState: () => saveState(watch, watching), log: console.log, skillLine })) return
+  const announceUpdate = kit
+    ? updateAnnouncer(homedir(), kit.version, defaultUpdateCheck(), console.log, () =>
+        hintFor(watch, eventReference({ kind: UPDATE_AVAILABLE_EVENT })),
+      )
+    : 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 }
+  try {
+    while (await pollOnce(watch, watching)) {
+      await Bun.sleep(POLL_MS)
+      pollLanes(watch, watching)
+      await announceUpdate?.()
+      if (endedByKitUpdate(kit, effects)) return
+    }
+  } finally {
+    sourceChanges?.close()
   }
 }
 
@@ -1029,10 +1312,34 @@ const filesOf = (root: string): Files => {
   return { state: join(directory, WATCHER_FILES.state), lock: join(directory, WATCHER_FILES.lock) }
 }
 
+/**
+ * The switch and the paths that always ask from the main checkout's config only, so a lane's worktree can neither switch
+ * `auto` on, shorten the list nor raise the cost limit; off and the kit's paths when that config cannot be read.
+ */
+const autoSettingsOf = (root: string, checkoutRoot: string, config: JackherdConfig) => {
+  try {
+    const main = checkoutRoot === root ? config : readConfig([root])
+    return {
+      auto: main.watch.parallelTasks.auto,
+      askPaths: [...AUTO_ASK_PATHS, ...main.guard.alwaysAsk],
+      maxTokens: main.watch.parallelTasks.maxTokens,
+      holdsDataPath: holdsDataPathIn(root),
+    }
+  } catch {
+    return {
+      auto: undefined,
+      askPaths: AUTO_ASK_PATHS,
+      maxTokens: config.watch.parallelTasks.maxTokens,
+      holdsDataPath: holdsDataPathIn(root),
+    }
+  }
+}
+
 /** The watch as the command line and the config set it up; throws when the config or the sprint is missing. */
 const watchOf = (options: WatchOptions): Watch => {
   const root = mainCheckout(process.cwd())
-  const { config, notes } = readResolvedConfig([worktreeRoot(process.cwd()), root])
+  const checkoutRoot = worktreeRoot(process.cwd())
+  const { config, notes } = readResolvedConfig([checkoutRoot, root])
   for (const note of notes) console.log(note)
   const settings = plansSettingsOf(config)
   const picked = boardFor(options.boardPath, [root, worktreeRoot(process.cwd())], settings, () =>
@@ -1048,9 +1355,13 @@ const watchOf = (options: WatchOptions): Watch => {
     deploy: config.watch.deploy,
     feedback: config.watch.feedback,
     checks: config.watch.checks,
+    parallelTasks: config.watch.parallelTasks,
+    taskSignalMinutes: config.watch.taskSignalMinutes,
+    parallelAuto: autoSettingsOf(root, checkoutRoot, config),
     previews: config.watch.previews,
     sources: config.watch.sources,
     texts: watchTexts(settings.responseLanguage),
+    skillCopies: skillCopiesFor(root, homedir(), config.skillPrefix, DEFAULT_SKILL_PREFIX),
     herdr: insideHerdr(settings.adapter, process.env),
   }
 }