jackherd 1.8.1 → 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/vocabulary/index.ts

@@ -93,6 +93,34 @@ export const APPOINTMENT_VOCABULARY: Record<
   },
 }
 
+/**
+ * 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'],
+  },
+}
+
 export const isPlanLanguage = (value: string): value is PlanLanguage =>
   (Object.values(PLAN_LANGUAGE) as string[]).includes(value)
 

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}`

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),

package/src/watch/failed-tests.ts

@@ -1,4 +1,5 @@
 import { terminalSafe } from '../plan-format/terminal-text'
+import { stripAnsi } from '../terminal/text'
 
 /** The most failed tests kept for one head commit. */
 export const FAILED_TEST_LIMIT = 50
@@ -29,24 +30,69 @@ const compiled = (pattern: string): RegExp | null => {
   }
 }
 
+/** `places` holds, by test name, the package or test file the log printed before the test; a test before any has none. */
+export type FailedTestScan = { tests: string[]; places: Record<string, string> }
+
+/** `##[group]`, which GitHub Actions folds a section behind, in front of a header line. */
+const GROUP_MARK = /^##\[group\]/
+
+/** The task header a monorepo runner (turbo) prints before a package's run: `@scope/name:test`, the package first. */
+const TASK_HEADER = /^(@[\w.-]+\/[\w.-]+|[\w.-]+):[\w:-]*test[\w:-]*$/
+
+/** The header Bun prints before the results of one test file: its path and a colon. */
+const FILE_HEADER = /^(\S+\.(?:test|spec)\.[cm]?[jt]sx?):$/
+
+/** Where the scan stands in the log: the package of the current task and the test file of the current run. */
+type ScanPlace = { task: string | null; file: string | null }
+
+/** The place after `line`: a task header starts a new package, a file header a new file. */
+const placeAfter = (place: ScanPlace, line: string): ScanPlace => {
+  const header = stripAnsi(line).replace(GROUP_MARK, '')
+  const task = TASK_HEADER.exec(header)?.[1]
+  if (task) return { task: nameOf(task), file: null }
+  const file = FILE_HEADER.exec(header)?.[1]
+  return file ? { ...place, file: nameOf(file) } : place
+}
+
+const cleanLine = (raw: string): string => raw.replace(/\r$/, '').replace(LOG_PREFIX, '')
+
 /**
- * The names of the failed tests in the log `gh run view <id> --log-failed` printed, in the order first seen. Each line
- * loses its job, step and timestamp prefix, then `pattern` (a regular expression) is matched against it: the first
- * group is the name, else the whole match. A test the log names twice (Bun lists it in the run and in the summary) is
- * listed once. Names are made terminal-safe and cut; at most `FAILED_TEST_LIMIT` are kept. A pattern that is no
- * regular expression finds nothing.
+ * The failed tests in the log `gh run view <id> --log-failed` printed, in the order first seen, with the place each
+ * was first seen in. Each line loses its job, step and timestamp prefix, then `pattern` (a regular expression) is
+ * matched against it: the first group is the name, else the whole match. The place is the package of the task header
+ * before it (`@scope/name:test`), else the test file Bun printed before it. A test the log names twice (Bun lists it
+ * in the run and in the summary) is listed once, at its first place. Names and places are made terminal-safe and cut;
+ * at most `FAILED_TEST_LIMIT` are kept. A pattern that is no regular expression finds nothing.
  */
-export const extractFailedTests = (log: string, pattern: string): string[] => {
+export const scanFailedTests = (log: string, pattern: string): FailedTestScan => {
   const expression = compiled(pattern)
-  if (!expression) return []
+  const places: Record<string, string> = {}
+  if (!expression) return { tests: [], places }
   const names = new Set<string>()
+  let place: ScanPlace = { task: null, file: null }
   for (const raw of log.split('\n')) {
     if (names.size >= FAILED_TEST_LIMIT) break
-    const line = raw.replace(/\r$/, '').replace(LOG_PREFIX, '')
+    const line = cleanLine(raw)
     if (line.length > MAX_LINE_LENGTH) continue
+    place = placeAfter(place, line)
     const match = expression.exec(line)
     const name = nameOf(match?.[1] ?? match?.[0] ?? '')
-    if (name !== '') names.add(name)
+    if (name === '' || names.has(name)) continue
+    names.add(name)
+    const where = place.task ?? place.file
+    if (where) places[name] = where
   }
-  return [...names]
+  return { tests: [...names], places }
 }
+
+/** `places` read back from the state file, for the names in `names` only, made terminal-safe and cut like the names. */
+export const sanitisedFailedTestPlaces = (
+  places: Readonly<Record<string, string>>,
+  names: readonly string[],
+): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(places).flatMap(([name, place]) => {
+      const shown = nameOf(name)
+      return names.includes(shown) && nameOf(place) !== '' ? [[shown, nameOf(place)]] : []
+    }),
+  )

package/src/watch/failure-read.ts

@@ -1,6 +1,6 @@
-import { extractFailedTests, FAILED_TEST_LIMIT } from './failed-tests'
+import { isRecord } from '../shared/is-record'
+import { FAILED_TEST_LIMIT, scanFailedTests } from './failed-tests'
 import { type GhAnswer, runGh } from './gh'
-import { isRecord } from './json-guards'
 
 /** How long `gh run view --log-failed` may take before the call is given up; a read that timed out is tried again. */
 export const LOG_TIMEOUT_MS = 30_000
@@ -8,8 +8,13 @@ export const LOG_TIMEOUT_MS = 30_000
 /** Of a longer log only this many characters from the end are kept; Bun repeats its failures in the summary there. */
 export const LOG_TAIL_CHARS = 2_000_000
 
-/** `running` is true when a run was still going, which is no failure of the read and is not counted as an attempt. */
-export type FailedTestsRead = { ok: true; tests: string[] } | { ok: false; running: boolean }
+/**
+ * `running` is true when a run was still going, which is no failure of the read and is not counted as an attempt.
+ * `places` names, by test, the package or test file the logs printed before it; absent when they named none.
+ */
+export type FailedTestsRead =
+  | { ok: true; tests: string[]; places?: Record<string, string> }
+  | { ok: false; running: boolean }
 
 type RunGh = (args: string[]) => Promise<GhAnswer>
 
@@ -51,6 +56,13 @@ export const readFailedTests = async (
   const answers = await Promise.all(runIds.map((runId) => run(logArgs(runId))))
   const logs = answers.flatMap((answer) => (answer.ok ? [answer.stdout] : []))
   if (logs.length < answers.length) return { ok: false, running: false }
-  const tests = new Set(logs.flatMap((text) => extractFailedTests(text, pattern)))
-  return { ok: true, tests: [...tests].slice(0, FAILED_TEST_LIMIT) }
+  const scans = logs.map((text) => scanFailedTests(text, pattern))
+  const tests = [...new Set(scans.flatMap((scan) => scan.tests))].slice(0, FAILED_TEST_LIMIT)
+  const places = Object.fromEntries(
+    tests.flatMap((name) => {
+      const place = scans.find((scan) => scan.places[name] !== undefined)?.places[name]
+      return place === undefined ? [] : [[name, place]]
+    }),
+  )
+  return { ok: true, tests, ...(Object.keys(places).length > 0 && { places }) }
 }