jackherd 1.8.0 → 1.9.0

package/src/task-signals/record.ts

@@ -0,0 +1,68 @@
+import { isRecord } from '../shared/is-record'
+import { cleanAgentName, cleanTaskText, MAX_TASK_TEXT } from './text'
+import type { TaskSignal } from './types'
+
+/** What `jh task start` stores in `.jackherd/tasks/<id>.json`: one record per agent, closed by `jh task done`. */
+export type TaskRecord = {
+  id: string
+  agent: string
+  text: string
+  startedAt: number
+  cwd: string
+  closedAt: number | null
+}
+
+const ID = /^[0-9a-f]{12}$/
+const ID_BYTES = 6
+
+/** The id of a record from random bytes the caller drew, so a test reaches the drawing; 12 hex characters. */
+export const buildTaskId = (randomBytes: Uint8Array): string =>
+  [...randomBytes.slice(0, ID_BYTES)].map((byte) => byte.toString(16).padStart(2, '0')).join('')
+
+export const isTaskRecord = (value: unknown): value is TaskRecord => {
+  if (!isRecord(value)) return false
+  const record = value
+  return (
+    typeof record.id === 'string' &&
+    ID.test(record.id) &&
+    typeof record.agent === 'string' &&
+    typeof record.text === 'string' &&
+    record.text.length <= MAX_TASK_TEXT &&
+    typeof record.startedAt === 'number' &&
+    typeof record.cwd === 'string' &&
+    (record.closedAt === null || typeof record.closedAt === 'number')
+  )
+}
+
+/** A fresh open record; the text and the agent name are cleaned here, whoever wrote them. */
+export const openRecord = (
+  fields: { id: string; agent: string; text: string; cwd: string },
+  now: number,
+): TaskRecord => ({
+  id: fields.id,
+  agent: cleanAgentName(fields.agent),
+  text: cleanTaskText(fields.text),
+  startedAt: now,
+  cwd: fields.cwd,
+  closedAt: null,
+})
+
+/** Whether `text` names the record's task: empty text names any, else it is the start of the record's text. */
+export const namesTask = (record: TaskRecord, text: string): boolean => {
+  const wanted = cleanTaskText(text)
+  return wanted === '' || record.text.startsWith(wanted)
+}
+
+/** The open records as signals; a record cleaned on write is cleaned again on read, as a hand-written file may differ. */
+export const recordSignals = (records: readonly TaskRecord[]): TaskSignal[] =>
+  records
+    .filter(({ closedAt }) => closedAt === null)
+    .map(({ agent, text, startedAt, cwd }) => ({
+      agent: cleanAgentName(agent),
+      source: 'jh' as const,
+      text: cleanTaskText(text),
+      startedAt,
+      cwd,
+    }))
+    .filter(({ text }) => text !== '')
+    .sort((left, right) => left.startedAt - right.startedAt)

package/src/task-signals/text.ts

@@ -0,0 +1,13 @@
+import { terminalSafe } from '../plan-format/terminal-text'
+
+/** The longest task text a signal carries; a plan task is matched on its first 200 characters as well. */
+export const MAX_TASK_TEXT = 200
+const MAX_AGENT_NAME = 100
+
+const capped = (text: string, max: number): string => terminalSafe(text.replace(/\s+/g, ' ')).trim().slice(0, max)
+
+/** Agent-written task text made safe to store and print: no control characters, one line, at most 200 characters. */
+export const cleanTaskText = (text: string): string => capped(text, MAX_TASK_TEXT)
+
+/** The same for the name of an agent. */
+export const cleanAgentName = (name: string): string => capped(name, MAX_AGENT_NAME)

package/src/task-signals/types.ts

@@ -0,0 +1,14 @@
+/** Who reported a task: Claude Code's task list, Codex's plan tool, or `jh task start`. */
+export type TaskSource = 'claude' | 'codex' | 'jh'
+
+/**
+ * One task an agent is working on right now. `agent` names the session or subagent that reported it, `startedAt` is
+ * epoch milliseconds, `cwd` the directory the agent worked in (its worktree tells the lane).
+ */
+export type TaskSignal = {
+  agent: string
+  source: TaskSource
+  text: string
+  startedAt: number
+  cwd: string
+}

package/src/terminal/open.ts

@@ -5,10 +5,16 @@ export type OpenEnvironment = {
   start: (command: string, args: string[]) => void
 }
 
-const OPENERS: Partial<Record<NodeJS.Platform, string>> = { darwin: 'open', linux: 'xdg-open' }
+const OPENERS: Partial<Record<NodeJS.Platform, (target: string) => string[]>> = {
+  darwin: (target) => ['open', target],
+  linux: (target) => ['xdg-open', target],
+  /** Not `cmd /c start`: cmd reads `&`, `|`, `%` and `^` in the target as its own syntax; rundll32 takes it as one argument. */
+  win32: (target) => ['rundll32', 'url.dll,FileProtocolHandler', target],
+}
 
-/** The command that opens a file or a link in the default application of the platform, null when there is none. */
-export const openerFor = (platform: NodeJS.Platform): string | null => OPENERS[platform] ?? null
+/** The command and arguments that open a file or a link in the default application of the platform, null when there is none. */
+export const openCommandFor = (platform: NodeJS.Platform, target: string): string[] | null =>
+  OPENERS[platform]?.(target) ?? null
 
 /** Linux opens things in a graphical session only; elsewhere the platform's opener is assumed to work. */
 export const hasDisplay = ({ platform, env }: Pick<OpenEnvironment, 'platform' | 'env'>): boolean =>
@@ -27,11 +33,12 @@ const systemEnvironment = (): OpenEnvironment => ({
  * opener for the platform, no display, the opener could not be started), null when it was started.
  */
 export const openInBrowser = (target: string, environment: OpenEnvironment = systemEnvironment()): string | null => {
-  const opener = openerFor(environment.platform)
-  if (!opener) return `no way to open ${target} on ${environment.platform}`
+  const command = openCommandFor(environment.platform, target)
+  if (!command) return `no way to open ${target} on ${environment.platform}`
   if (!hasDisplay(environment)) return 'no display'
+  const [opener, ...args] = command
   try {
-    environment.start(opener, [target])
+    environment.start(opener, args)
     return null
   } catch (error) {
     return `${opener} ${target}: ${error instanceof Error ? error.message : String(error)}`

package/src/terminal/text.ts

@@ -34,6 +34,13 @@ const FAINT_OFF = `${ESC}[22m`
 const BAR_WIDTH = 10
 
 const style = (code: string) => (text: string) => `${ESC}[${code}m${text}${RESET}`
+const BRAND_TEAL_TRUE_COLOUR = '38;2;3;181;189'
+const BRAND_TEAL_256 = '38;5;37'
+
+/** The brand teal `#03B5BD` as true colour where `COLORTERM` says `truecolor` or `24bit`, else 256-colour 37. */
+export const tealCodeOf = (env: Record<string, string | undefined>): string =>
+  env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit' ? BRAND_TEAL_TRUE_COLOUR : BRAND_TEAL_256
+
 export const paint = {
   bold: style('1'),
   dim: style('2'),
@@ -41,7 +48,7 @@ export const paint = {
   green: style('32'),
   yellow: style('33'),
   magenta: style('35'),
-  teal: style('38;5;37'),
+  teal: style(tealCodeOf(process.env)),
   cyan: style('36'),
   inverse: style('7'),
 }

package/src/terminal/width.ts

@@ -1,4 +1,5 @@
 const VARIATION_SELECTOR = 0xfe0f
+const TEXT_SELECTOR = 0xfe0e
 const ZERO_WIDTH_JOINER = 0x200d
 const COMBINING_MARKS: readonly [number, number][] = [[0x0300, 0x036f]]
 
@@ -59,7 +60,7 @@ const within = (ranges: readonly [number, number][], codePoint: number): boolean
  * variation selector (`⏸`) is one cell on its own; `textWidth` counts it as two when the selector follows.
  */
 export const cellWidth = (codePoint: number): number => {
-  if (codePoint === VARIATION_SELECTOR || codePoint === ZERO_WIDTH_JOINER) return 0
+  if (codePoint === VARIATION_SELECTOR || codePoint === TEXT_SELECTOR || codePoint === ZERO_WIDTH_JOINER) return 0
   if (within(COMBINING_MARKS, codePoint)) return 0
   return within(WIDE, codePoint) ? 2 : 1
 }

package/src/update/command.ts

@@ -14,6 +14,7 @@ import { defaultUpdateCheck, lockedVersion } from '../sync/if-changed'
 import { locateKit } from '../sync/kit-source'
 import { readInstalledVersion } from '../version/installed-version'
 import { CLI_NAME } from '../version/release'
+import { rewriteConfigShares } from './config-shares'
 import { detectPackageManager, legacyPackageRoot, shellHostedGlobalRoot } from './package-manager'
 import { runUpdate, UPDATE_EXIT, type UpdateAdapters } from './update'
 
@@ -52,6 +53,7 @@ const adaptersFor = async (): Promise<UpdateAdapters> => {
     home,
     projectRoot: findProjectRoot(process.cwd(), home, existsSync),
     hasProjectKit: (root) => hasProjectInstall(root, existsSync),
+    rewriteConfigShares,
     log: (line) => console.log(line),
   }
 }

package/src/update/config-shares.ts

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { contextSharesTextInTokens } from '../config/context-shares'
+import { PROJECT_CONFIG_PATH } from '../config/location'
+
+type Converted = { text: string; notes: string[] }
+
+/** The file's text with its shares in tokens; null when it is missing or not JSON, which reading the config names. */
+const converted = (path: string): Converted | null => {
+  if (!existsSync(path)) return null
+  try {
+    return contextSharesTextInTokens(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Writes the context thresholds of `root`'s `.jackherd/config.json` as tokens when the file still gives them as a
+ * share, and returns a line for each block that changed. A project without an install of its own has no sync that
+ * would do it. A missing or unreadable file is left alone: reading the config names that error. A failed write
+ * throws, so `jh update` reports it.
+ */
+export const rewriteConfigShares = (root: string): string[] => {
+  const path = join(root, PROJECT_CONFIG_PATH)
+  const result = converted(path)
+  if (result === null || result.notes.length === 0) return []
+  writeFileSync(path, result.text)
+  return result.notes.map((note) => `${PROJECT_CONFIG_PATH}: ${note}`)
+}

package/src/update/update.ts

@@ -28,6 +28,8 @@ export type UpdateAdapters = {
    * The lock's existence counts, not its validity: a broken lock is synced, and the sync names the error.
    */
   hasProjectKit: (root: string) => boolean
+  /** Writes the context thresholds in the project's config as tokens when they are still a share; returns a line for each change. */
+  rewriteConfigShares: (root: string) => string[]
   log: (line: string) => void
 }
 
@@ -46,6 +48,11 @@ const notInstalledLine = (projectRoot: string): string =>
 const installedProject = (adapters: UpdateAdapters): string | null =>
   adapters.projectRoot && adapters.hasProjectKit(adapters.projectRoot) ? adapters.projectRoot : null
 
+/** Rewrites the context thresholds of a project without an install, which no sync does, and says what changed. */
+const logConfigShares = (adapters: UpdateAdapters, root: string): void => {
+  for (const line of adapters.rewriteConfigShares(root)) adapters.log(line)
+}
+
 /** The syncs that bring `~/.claude` and the project to the new files, in the order they run. */
 const syncSteps = async (
   adapters: UpdateAdapters,
@@ -107,6 +114,7 @@ const updateToLatest = async (adapters: UpdateAdapters, manager: PackageManager)
   const jhWasOnPath = adapters.jhOnPath()
   if (jhWasOnPath && !isNewerVersion(latest, installedVersion)) {
     log(`${CLI_NAME} ${installedVersion} is the latest release.`)
+    if (adapters.projectRoot && !installedProject(adapters)) logConfigShares(adapters, adapters.projectRoot)
     return UPDATE_EXIT.ok
   }
   const installed = await installAndVerify(adapters, manager, latest)
@@ -115,7 +123,10 @@ const updateToLatest = async (adapters: UpdateAdapters, manager: PackageManager)
   const synced = await syncAfterInstall(adapters, project)
   if (synced !== UPDATE_EXIT.ok) return synced
   log(doneLine(adapters, manager, latest, jhWasOnPath))
-  if (adapters.projectRoot && !project) log(notInstalledLine(adapters.projectRoot))
+  if (adapters.projectRoot && !project) {
+    logConfigShares(adapters, adapters.projectRoot)
+    log(notInstalledLine(adapters.projectRoot))
+  }
   return UPDATE_EXIT.ok
 }
 

package/src/vocabulary/index.ts

@@ -66,7 +66,7 @@ export const APPROVAL_TEXTS: Record<PlanLanguage, { allow: string; deny: string;
 
 /**
  * The board section of agreed times, which the watcher reads: its heading, the header names of its columns (when,
- * action, origin, status; found by name, in any order) and the lower-case words a status cell of a still open
+ * action, origin, status, found by name in any order; the status column may also carry a name of `statusAlso`) and the lower-case words a status cell of a still open
  * appointment starts with.
  */
 export const APPOINTMENT_VOCABULARY: Record<
@@ -74,17 +74,49 @@ export const APPOINTMENT_VOCABULARY: Record<
   {
     heading: string
     columns: { when: string; action: string; origin: string; status: string }
+    /** Further header names that count as the status column. */
+    statusAlso: readonly string[]
     open: readonly string[]
   }
 > = {
   [PLAN_LANGUAGE.de]: {
     heading: 'Termine',
     columns: { when: 'Wann', action: 'Aktion', origin: 'Herkunft', status: 'Stand' },
+    statusAlso: ['Status'],
     open: ['offen'],
   },
   [PLAN_LANGUAGE.en]: {
     heading: 'Appointments',
     columns: { when: 'When', action: 'Action', origin: 'Origin', status: 'Status' },
+    statusAlso: [],
+    open: ['open'],
+  },
+}
+
+/**
+ * The board section of what waits on the user's answer (a sent preview, an open question, a report to accept): its
+ * heading, the header names of its columns (since, item, origin, status, found by name in any order; the status
+ * column may also carry a name of `statusAlso`) and the lower-case words a status cell of a still open item starts with.
+ */
+export const WAITING_VOCABULARY: Record<
+  PlanLanguage,
+  {
+    heading: string
+    columns: { since: string; item: string; origin: string; status: string }
+    statusAlso: readonly string[]
+    open: readonly string[]
+  }
+> = {
+  [PLAN_LANGUAGE.de]: {
+    heading: 'Wartet auf dich',
+    columns: { since: 'Seit', item: 'Punkt', origin: 'Herkunft', status: 'Stand' },
+    statusAlso: ['Status'],
+    open: ['offen'],
+  },
+  [PLAN_LANGUAGE.en]: {
+    heading: 'Waiting for you',
+    columns: { since: 'Since', item: 'Item', origin: 'Origin', status: 'Status' },
+    statusAlso: [],
     open: ['open'],
   },
 }

package/src/waiting/command.ts

@@ -0,0 +1,35 @@
+import { terminalSafe } from '../plan-format/terminal-text'
+import type { WaitingItem } from '../plan-format/waiting'
+import { mainCheckout } from '../plans/git'
+import { sentWaitingItems } from '../plans/sent-files'
+import { closeAllSentRecords, closeSentRecords, readSentRecords } from '../plans/sent-files-read'
+import { CLI_NAME } from '../version/release'
+
+const USAGE = `usage: ${CLI_NAME} waiting [close <id> ... | close --all]`
+
+/** The lines `jh waiting` prints: id, time and text of each item, made safe for the terminal; a note when none waits. */
+export const waitingListing = (items: readonly WaitingItem[]): string[] =>
+  items.length === 0
+    ? ['nothing waits on you']
+    : items.map(({ since, item, id }) => terminalSafe(`${id} · ${since} · ${item}`))
+
+/**
+ * `jh waiting` lists the files sent to the user that no one closed (their id, time and caption);
+ * `jh waiting close <id> ...` or `close --all` closes them once the user has answered. Exit 0, 1 on a wrong command line.
+ */
+export const run = async (args: string[]): Promise<number> => {
+  const root = mainCheckout(process.cwd())
+  if (args.length === 0) {
+    for (const line of waitingListing(sentWaitingItems(readSentRecords(root), Date.now()))) console.log(line)
+    return 0
+  }
+  const [command, ...rest] = args
+  if (command !== 'close' || rest.length === 0) {
+    console.error(USAGE)
+    return 1
+  }
+  const now = Date.now()
+  const closed = rest.includes('--all') ? closeAllSentRecords(root, now) : closeSentRecords(root, rest, now)
+  console.log(`closed ${closed}`)
+  return 0
+}

package/src/watch/appointments.ts

@@ -1,6 +1,7 @@
+import { twoDigits } from '../plan-format/clock'
 import { firstTableWithHeader, sectionLines } from '../plan-format/markdown'
+import { isRecord } from '../shared/is-record'
 import { APPOINTMENT_VOCABULARY, type PlanLanguage } from '../vocabulary'
-import { isRecord } from './json-guards'
 
 export const APPOINTMENT_EVENT = { due: 'due', unreadable: 'appointment unreadable' } as const
 
@@ -90,8 +91,6 @@ export const parseAppointmentTime = (text: string, now: Date): Date | null => {
   return parts.year === null ? nearestToClock(parts, now) : localTime(parts, parts.year)
 }
 
-const twoDigits = (value: number): string => String(value).padStart(2, '0')
-
 /** The local time to the minute and the action: a moved appointment gets a new key, a reworded day name does not. */
 export const appointmentKey = (when: Date, action: string): string =>
   `${when.getFullYear()}-${twoDigits(when.getMonth() + 1)}-${twoDigits(when.getDate())}T${twoDigits(when.getHours())}:${twoDigits(when.getMinutes())} ${action}`
@@ -132,10 +131,11 @@ const tableOfRow = (
  * listed as unreadable as a whole, with its header and the missing names; a section without a table has no rows.
  */
 export const readAppointmentTable = (board: string, language: PlanLanguage, now: Date): AppointmentTable => {
-  const { heading, columns } = APPOINTMENT_VOCABULARY[language]
+  const { heading, columns, statusAlso } = APPOINTMENT_VOCABULARY[language]
   const { header, rows } = firstTableWithHeader(sectionLines(board, heading))
   if (header.length === 0) return { appointments: [], unreadable: [] }
-  const needed = [columns.when, columns.action, columns.status]
+  const statusName = [columns.status, ...statusAlso].find((name) => header.includes(name)) ?? columns.status
+  const needed = [columns.when, columns.action, statusName]
   const missing = needed.filter((name) => !header.includes(name))
   if (missing.length > 0)
     return {

package/src/watch/approvals.ts

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { isRecord } from './json-guards'
+import { MS_PER_MINUTE } from '../plan-format/clock'
+import { isRecord } from '../shared/is-record'
 
 export const APPROVAL_EVENT = 'approval'
 
@@ -49,7 +50,6 @@ export const isApprovalRequestFile = (value: unknown): value is ApprovalRequestF
   (value.usedAt === null || typeof value.usedAt === 'number')
 
 const REPORT_MINUTES = 30
-const MS_PER_MINUTE = 60_000
 
 /** One event per open request younger than 30 minutes the watcher has not reported yet; an older one is stale. */
 export const approvalEvents = (

package/src/watch/command.ts

@@ -37,11 +37,14 @@ import { contextReport } from '../context/report'
 import { agentLog } from '../context/session-log'
 import { type LaneProgress, parseSprintLanes, type SprintLane } from '../plan-format'
 import { terminalSafe } from '../plan-format/terminal-text'
+import { openWaitingItems } from '../plan-format/waiting'
 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 { discoverLanes, isUnchanged, laneSetChange, laneSetLines } from '../plans/lane-discovery'
+import { sentWaitingItems } from '../plans/sent-files'
+import { readSentRecords } from '../plans/sent-files-read'
 import { CLOCK_LOCALE, type PlansSettings, plansSettingsOf, worktreeOf } from '../plans/settings'
 import { boardTexts } from '../plans/texts'
 import { defaultUpdateCheck } from '../sync/if-changed'
@@ -107,6 +110,7 @@ import {
   watchEventLine,
 } from './lane-report'
 import { laneReportPath, readLaneReport, reportMtime } from './lane-report-file'
+import { restNote } from './lane-rest'
 import { branchOf, fetchBaseWhenMoved } from './lane-sources'
 import {
   advanceBaseline,
@@ -148,8 +152,17 @@ 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 { readTaskParallelInputs } from './task-parallel-read'
 import { type WatchTexts, watchTexts } from './texts'
 import { updateAnnouncer } from './update-available'
+import { waitingLine } from './waiting-line'
 import {
   coordinatorWatchEvent,
   deployEvents,
@@ -184,6 +197,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,6 +217,7 @@ type Watch = {
   deploy: DeployConfig | undefined
   feedback: FeedbackConfig
   checks: ChecksConfig
+  parallelTasks: ParallelTasksConfig
   previews: PreviewsConfig
   sources: SourceSettings[]
   texts: WatchTexts
@@ -260,6 +275,8 @@ type Watching = {
   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 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. */
@@ -299,6 +316,7 @@ 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,
     approvals: watching.approvalRequests ? recordApprovals(watching.approvalRequests) : withReads.approvals,
     sources: recordWatchedSources(withReads.sources, watching.sourceRuns, watch.sources, watching.githubReadAt),
     appointments: watching.appointments
@@ -340,6 +358,12 @@ 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 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({
@@ -451,6 +475,7 @@ const boardReadOf = async (
 
 /** 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 +492,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),
   }
 }
 
@@ -500,16 +526,17 @@ const statusLinesOf = async (
   const others = otherPullRequestsLine(pullRequests, github?.own ?? [], watch.texts)
   const { progress, checkoutRows, notes } = await boardReadOrNote(watch, watching.lanes)
   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),
   )
   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)],
   }
 }
 
@@ -813,6 +840,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 => {
+  const board = readBoardText(watch)
+  const sends = sentWaitingItems(readSentRecords(watch.root), Date.now())
+  return waitingLine([...(board === null ? [] : openWaitingItems(board, watch.settings.planLanguage)), ...sends])
+}
+
 /** The board's lanes, null when the board cannot be read. */
 const readSprintLanes = (watch: Watch): SprintLane[] | null => {
   const board = readBoardText(watch)
@@ -896,6 +930,39 @@ const report = async (
   return shown
 }
 
+/**
+ * The parallel-task proposals of this heartbeat, one event per open lane whose situation changed since the last
+ * heartbeat and that has a proposal, 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 taskParallelEventsOf = (
+  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, taskParallelReport(watching.taskParallels[lane], input)] as const,
+    )
+    return {
+      events: reports.flatMap(([lane, { proposal }]) =>
+        proposal ? [{ kind: TASK_PARALLEL_EVENT, lane, line: formatTaskParallelLine(lane, proposal) }] : [],
+      ),
+      fingerprints: Object.fromEntries(reports.map(([lane, { fingerprint }]) => [lane, fingerprint])),
+    }
+  } catch {
+    return { events: [], fingerprints: {} }
+  }
+}
+
 /**
  * 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
@@ -907,7 +974,16 @@ const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: numbe
   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 rests = Object.fromEntries(
+    watching.lanes.flatMap((lane) => {
+      const rest = restNoteOf(watch, lane, watching.current[lane]?.status)
+      return rest === null ? [] : [[lane, rest]]
+    }),
+  )
+  console.log(streamHeartbeatLine(clock(now), watching.lanes, watching.current, notes, rests, waitingLineOf(watch)))
+  const { events, fingerprints } = taskParallelEventsOf(watch, watching, now)
+  watching.taskParallels = { ...watching.taskParallels, ...fingerprints }
+  for (const event of events) console.log(watchEventLine(event, null))
 }
 
 /**
@@ -941,9 +1017,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 { events: proposals, fingerprints } = taskParallelEventsOf(watch, watching, now)
+    watching.taskParallels = { ...watching.taskParallels, ...fingerprints }
+    next = await report(watch, watching, [], [{ kind: WATCH_EVENT.heartbeat }, ...proposals], {
+      ...recordedOf(watch, watching),
+      statusLines: null,
+    })
   } else {
-    if (heartbeat) await printStreamHeartbeat(watch, watching, now)
+    if (heartbeat) {
+      await printStreamHeartbeat(watch, watching, now)
+      next = recordedOf(watch, watching)
+    }
     if (due) writePrivate(watch.files.state, JSON.stringify(next))
     watching.baseline = advanceBaseline(watching.baseline, watching.current)
   }
@@ -983,6 +1067,7 @@ const initialWatching = (
   laneReadings: {},
   laneModelReadings: {},
   laneParallelReadings: {},
+  taskParallels: start.state.taskParallels,
   approvalRequests: null,
   appointments: null,
   planViews: { failureReported: false },
@@ -1048,6 +1133,7 @@ const watchOf = (options: WatchOptions): Watch => {
     deploy: config.watch.deploy,
     feedback: config.watch.feedback,
     checks: config.watch.checks,
+    parallelTasks: config.watch.parallelTasks,
     previews: config.watch.previews,
     sources: config.watch.sources,
     texts: watchTexts(settings.responseLanguage),