jackherd 1.11.2 → 1.12.0

package/src/plans/appointment-rows.ts

@@ -1,83 +1,72 @@
-import { DAY_MS, twoDigits } from '../plan-format/clock'
-import { padVisible } from '../terminal/text'
-import { textWidth } from '../terminal/width'
+import { twoDigits } from '../plan-format/clock'
 import type { PlanLanguage } from '../vocabulary'
-import { type Appointment, readAppointmentTable } from '../watch/appointments'
+import { type Appointment, readAppointmentTable, type UnreadableAppointment } from '../watch/appointments'
 import { ASK_KIND } from './ask-target'
+import { isSameWeek } from './calendar-days'
 import { DONE_KIND } from './row-targets'
-import { shortTitle } from './task-name'
-import { type BlockButton, type BlockItem, DONE_BUTTON, MOVE_BUTTON, RUN_BUTTON } from './waiting-click'
+import { type BlockButton, DONE_BUTTON, MOVE_BUTTON, RUN_BUTTON } from './waiting-click'
 
-/** An open appointment as the herd shows it: `label` is the weekday and the time, `Mon 09:03` (the weekday is English whatever the board's language); `key` is the watcher's. */
-export type AppointmentRow = { key: string; when: string; label: string; action: string }
+/**
+ * An open appointment as the herd shows it: `label` is the weekday and the time, `Mon 09:03` (the weekday is English
+ * whatever the board's language), or `time open` for a row whose time cell cannot be read; `at` is its time in epoch
+ * milliseconds, null for such a row; `key` is the watcher's, or the cell and the action for a row without a time.
+ */
+export type AppointmentRow = { key: string; when: string; at: number | null; label: string; action: string }
 
-/** The appointment block: the open rows, the earliest first. */
-export type AppointmentBlock = { rows: AppointmentRow[] }
+/** The label of an open row whose time cell cannot be read. */
+export const TIME_OPEN = 'time open'
 
-const APPOINTMENT_MARK = '◷'
+const TABLE_CELL_SEPARATOR = '|'
 
 const WEEKDAY_LOCALE = 'en-US'
 
 const weekdayOf = (when: Date): string => new Intl.DateTimeFormat(WEEKDAY_LOCALE, { weekday: 'short' }).format(when)
 
-const DATE_FROM_DAYS_AHEAD = 7
-
-const startOfDay = (when: Date): number => new Date(when.getFullYear(), when.getMonth(), when.getDate()).getTime()
-
-const daysAhead = (when: Date, now: Date): number => Math.round((startOfDay(when) - startOfDay(now)) / DAY_MS)
-
-/** The weekday names a day within the week; from a week on it is the date, `13.01.`, since the weekday would repeat. */
+/**
+ * The weekday names a day of the running week, Monday to Sunday, ahead or back; outside it the date follows, `Mon 26.10.`,
+ * since the weekday alone would name a day of this week.
+ */
 const dayOf = (when: Date, now: Date): string =>
-  daysAhead(when, now) >= DATE_FROM_DAYS_AHEAD
-    ? `${twoDigits(when.getDate())}.${twoDigits(when.getMonth() + 1)}.`
-    : weekdayOf(when)
+  isSameWeek(when, now)
+    ? weekdayOf(when)
+    : `${weekdayOf(when)} ${twoDigits(when.getDate())}.${twoDigits(when.getMonth() + 1)}.`
 
 const rowOf =
   (now: Date) =>
   ({ when, whenText, action, key }: Appointment): AppointmentRow => ({
     key,
     when: whenText,
+    at: when.getTime(),
     label: `${dayOf(when, now)} ${twoDigits(when.getHours())}:${twoDigits(when.getMinutes())}`,
     action,
   })
 
+const timeOpenRowOf = ({ whenText, action }: UnreadableAppointment): AppointmentRow => ({
+  key: `${whenText} ${action}`,
+  when: whenText,
+  at: null,
+  label: TIME_OPEN,
+  action,
+})
+
+/** A row of the table, not the table itself read as unreadable for a missing column: a cell holds no `|`. */
+const isTableRow = ({ whenText }: UnreadableAppointment): boolean => !whenText.includes(TABLE_CELL_SEPARATOR)
+
 /**
- * The open appointments of the board's section, read as the watcher reads them, the earliest first. A done row, a
- * row whose time cannot be read and a board without the section give no row.
+ * The open appointments of the board's section, read as the watcher reads them: those whose time cannot be read first,
+ * as `time open`, then the others, the earliest first. A done row and a board without the section give no row.
  */
-export const appointmentRows = (board: string, language: PlanLanguage, now: Date): AppointmentRow[] =>
-  readAppointmentTable(board, language, now)
-    .appointments.filter(({ open }) => open)
+export const appointmentRows = (board: string, language: PlanLanguage, now: Date): AppointmentRow[] => {
+  const { appointments, unreadable } = readAppointmentTable(board, language, now)
+  const timed = appointments
+    .filter(({ open }) => open)
     .sort((left, right) => left.when.getTime() - right.when.getTime())
-    .map(rowOf(now))
-
-/** The block of the board's open appointments, as the herd shows them. */
-export const appointmentBlock = (board: string, language: PlanLanguage, now: Date): AppointmentBlock => ({
-  rows: appointmentRows(board, language, now),
-})
-
-const appointmentKey = ({ key }: AppointmentRow): string => `appointment>${key}`
+  return [...unreadable.filter(isTableRow).map(timeOpenRowOf), ...timed.map(rowOf(now))]
+}
 
-const buttonsOf = ({ when, action }: AppointmentRow): BlockButton[] => [
+/** `[done]` closes the row, `[run]` asks the coordinator to run it now, `[move]` to ask the user for a new time. */
+export const appointmentButtons = ({ when, action }: AppointmentRow): BlockButton[] => [
   { label: DONE_BUTTON, click: { done: { kind: DONE_KIND.appointment, when, action } } },
   { label: RUN_BUTTON, click: { ask: { kind: ASK_KIND.appointmentRun, when, action } } },
   { label: MOVE_BUTTON, click: { ask: { kind: ASK_KIND.appointmentMove, when, action } } },
 ]
-
-/** The rows as the block draws them; a click on the row only expands it, the buttons close it, run it or move it. */
-export const appointmentItems = (rows: readonly AppointmentRow[]): BlockItem[] => {
-  const timeWidth = Math.max(0, ...rows.map(({ label }) => textWidth(label)))
-  return rows.map((row) => ({
-    key: appointmentKey(row),
-    mark: APPOINTMENT_MARK,
-    lead: padVisible(row.label, timeWidth),
-    text: row.action,
-    title: shortTitle(row.action),
-    url: null,
-    ask: null,
-    buttons: buttonsOf(row),
-  }))
-}
-
-/** The keys of all rows, the shown ones and the `+<n>` rest alike: what the fold of the block remembers. */
-export const appointmentKeys = (rows: readonly AppointmentRow[]): string[] => rows.map(appointmentKey)

package/src/plans/board-rows.ts

@@ -60,3 +60,17 @@ export const boardRowsOf = (baseText: string, checkoutText: string, language: Pl
   if (checkoutText === baseText) return { lanes, rowsFromCheckout: 0 }
   return withCheckoutRows(lanes, parseSprintLanes(checkoutText, language))
 }
+
+/** `boardRowsOf` that keeps its last answer: the board seldom changes between two reads, and parsing it holds the event loop. */
+export type BoardRowsReader = typeof boardRowsOf
+
+/** A `BoardRowsReader` that parses again only when a text or the language differs from its last call. */
+export const boardRowsReader = (): BoardRowsReader => {
+  let last: { baseText: string; checkoutText: string; language: PlanLanguage; rows: BoardRows } | null = null
+  return (baseText, checkoutText, language) => {
+    if (last?.baseText !== baseText || last.checkoutText !== checkoutText || last.language !== language) {
+      last = { baseText, checkoutText, language, rows: boardRowsOf(baseText, checkoutText, language) }
+    }
+    return last.rows
+  }
+}

package/src/plans/calendar-days.ts

@@ -0,0 +1,29 @@
+import { DAY_MS } from '../plan-format/clock'
+
+const DAYS_PER_WEEK = 7
+
+const startOfDay = (when: Date): number => new Date(when.getFullYear(), when.getMonth(), when.getDate()).getTime()
+
+/** Days since the last Monday: 0 on a Monday, 6 on a Sunday. */
+const daysSinceMonday = (when: Date): number => (when.getDay() + DAYS_PER_WEEK - 1) % DAYS_PER_WEEK
+
+/**
+ * Calendar days from `from` to `to` in the clock's time zone, negative when `to` is earlier: 23:59 to 00:01 is one
+ * day, 00:01 to 23:59 of the same day none. Rounded, so a day of 23 or 25 hours at a clock change still counts as one.
+ */
+export const calendarDaysBetween = (from: Date, to: Date): number =>
+  Math.round((startOfDay(to) - startOfDay(from)) / DAY_MS)
+
+/** The same wall-clock time `days` calendar days later (earlier for a negative count), across a clock change too. */
+export const addCalendarDays = (when: Date, days: number): Date => {
+  const moved = new Date(when)
+  moved.setDate(moved.getDate() + days)
+  return moved
+}
+
+/** Whether both times fall in the same calendar week, Monday to Sunday, in the clock's time zone. */
+export const isSameWeek = (left: Date, right: Date): boolean =>
+  calendarDaysBetween(
+    addCalendarDays(left, -daysSinceMonday(left)),
+    addCalendarDays(right, -daysSinceMonday(right)),
+  ) === 0

package/src/plans/click-hint.ts

@@ -0,0 +1,94 @@
+import { phaseLabel } from '../plan-format'
+import { pullRequestNumberOfKey } from './pull-requests'
+import { LINKS_KEY_PREFIX } from './row-focus'
+import {
+  BACKLOG_KEY,
+  finishedKey,
+  isBlockFolded,
+  isLaneOpen,
+  isLanesOpen,
+  isTaskRestKey,
+  itemPhaseOfKey,
+  LANES_KEY,
+  laneOfKey,
+  nextKey,
+  phaseIdOfKey,
+  type Selection,
+  TOP_BLOCK,
+  type TopBlockId,
+  topBlockOfKey,
+  WAITING_KEY,
+} from './selection'
+import { TEXTS } from './texts'
+import { type BlockRow, mainClickOf } from './waiting-click'
+
+/** The status a lane's agent reports, by the lane's name; null without an agent. */
+export type AgentOf = (lane: string) => string | null
+
+const NEXT_PREFIX = nextKey('')
+const DONE_PREFIX = finishedKey('')
+
+/** The heads of the folded blocks of the body by their names; the lanes block opens and folds by its own flag. */
+const BLOCK_NAMES: Record<string, string> = {
+  [WAITING_KEY]: TEXTS.waitingHeading,
+  [BACKLOG_KEY]: TEXTS.backlogHeading,
+}
+
+/** The blocks on top by their names, whose heads open and fold them. */
+const TOP_BLOCK_NAMES: Record<TopBlockId, string> = {
+  [TOP_BLOCK.yourTurn]: TEXTS.yourTurnHeading,
+  [TOP_BLOCK.sources]: TEXTS.sourceHeading,
+}
+
+/** `opens <name>` or `folds <name>` for a row that opens and folds, by whether it is open now. */
+const foldHint = (open: boolean, name: string): string => (open ? TEXTS.hintFolds(name) : TEXTS.hintOpens(name))
+
+/** What a click on a row of a block on top does, which enter does too: ask the coordinator, or open it. */
+const blockHint = (row: BlockRow): string | null => {
+  const click = mainClickOf(row)
+  if (!click) return null
+  return 'ask' in click ? TEXTS.hintBlockAsks : TEXTS.hintBlockOpens
+}
+
+/** What a click does on a row of the body that opens and folds, by the shape of its key; null for another key. */
+const foldingHint = (key: string, state: Selection, agentOf: AgentOf): string | null => {
+  const lane = laneOfKey(key)
+  if (lane !== null) return foldHint(isLaneOpen(state, lane, agentOf(lane)), lane)
+  if (key === LANES_KEY) return foldHint(isLanesOpen(state), TEXTS.lanesHeading)
+  const top = topBlockOfKey(key)
+  if (top !== null) return foldHint(!isBlockFolded(state, top), TOP_BLOCK_NAMES[top])
+  const open = state.expanded.has(key)
+  const block = BLOCK_NAMES[key]
+  if (block) return foldHint(open, block)
+  if (itemPhaseOfKey(key) !== null) return foldHint(open, TEXTS.hintTask)
+  if (isTaskRestKey(key)) return foldHint(open, TEXTS.hintTaskRest)
+  const phase = phaseIdOfKey(key)
+  if (phase !== null) return open ? TEXTS.hintFoldsTasks(phaseLabel(phase)) : TEXTS.hintListsTasks(phaseLabel(phase))
+  if (key.startsWith(NEXT_PREFIX)) return foldHint(open, TEXTS.hintNextPhases)
+  if (key.startsWith(DONE_PREFIX)) return foldHint(open, TEXTS.hintDonePhases)
+  return null
+}
+
+/** What a click does on a row of the body: open or fold it, or open the pull request it names. */
+const bodyHint = (key: string, state: Selection, agentOf: AgentOf): string | null => {
+  const number = pullRequestNumberOfKey(key)
+  return number === null ? foldingHint(key, state, agentOf) : TEXTS.hintOpens(`#${number}`)
+}
+
+/**
+ * The footer line that says what a click or a key does on the row under the mouse, else the selected one:
+ * `click or → opens search-index · ? help`. `blockRow` finds a row of the blocks on top by its key, `agentOf` the
+ * status of a lane's agent, which decides whether a lane without a fold of its own is drawn open. Null while no row
+ * has the focus, the mouse is on a line of links, or the row has nothing a click does.
+ */
+export const clickHint = (
+  state: Selection,
+  blockRow: (key: string) => BlockRow | null,
+  agentOf: AgentOf = () => null,
+): string | null => {
+  const key = state.hovered ?? state.selected
+  if (!key || key.startsWith(LINKS_KEY_PREFIX)) return null
+  const row = blockRow(key)
+  const hint = row ? blockHint(row) : bodyHint(key, state, agentOf)
+  return hint ? TEXTS.clickHint(hint) : null
+}

package/src/plans/command.ts

@@ -1,6 +1,7 @@
 import { homedir } from 'node:os'
 import { TERMINAL_ADAPTER } from '../config/schema'
 import { laneStatusSourceFor } from '../terminal'
+import { listHerdrAgents } from '../terminal/herdr'
 import { startedKit } from '../version/started-kit'
 import { boardFor, foundLanesOf } from './board-pick'
 import { ensurePlanPanes } from './ensure-panes'
@@ -11,22 +12,20 @@ import { recallLanes, rememberLanes } from './herd-memory'
 import { runLive } from './live'
 import { parseOptions } from './options'
 import { isSupervisedChild } from './restart-decision'
-import { CLOCK_LOCALE, readSettings } from './settings'
+import { type PlansSettings, readSettings } from './settings'
 import { loadSnapshot, type Source } from './snapshot'
 import { superviseView } from './supervisor'
 import { frameText, paneWidth, renderSnapshot, startSelection } from './view'
 
+/** herdr's agents read without holding the event loop, so the live view keeps answering keys during a refresh. */
+const agentListOf = (settings: PlansSettings): Pick<Source, 'listAgents'> =>
+  settings.adapter === TERMINAL_ADAPTER.herdr ? { listAgents: () => listHerdrAgents() } : {}
+
 const printOnce = async (source: Source): Promise<void> => {
   const memories = recallLanes(source.root)
   const snapshot = await loadSnapshot(source, await fetchPullRequests(source.root), memories)
   rememberLanes(source.root, memories, snapshot.documents.laneOrder)
-  const screen = renderSnapshot(
-    snapshot,
-    startSelection(snapshot, source.options),
-    snapshot.errors,
-    paneWidth(),
-    CLOCK_LOCALE,
-  )
+  const screen = renderSnapshot(snapshot, startSelection(snapshot, source.options), snapshot.errors, paneWidth())
   console.log(frameText(screen, Boolean(process.stdout.isTTY)))
 }
 
@@ -58,7 +57,7 @@ export const run = async (args: string[], home: string = homedir()): Promise<num
       for (const line of lines.length > 0 ? lines : ['every herd pane is running']) console.log(line)
       return 0
     }
-    const source = { root, sprintFile: picked.file, options, settings, terminal }
+    const source: Source = { root, sprintFile: picked.file, options, settings, terminal, ...agentListOf(settings) }
     if (options.once || !process.stdout.isTTY) await printOnceWithNotice(source, picked.notice)
     else if (isSupervisedChild(process.env)) await startExclusive(claimOwnTerminal, () => runLive(source))
     else process.exit(await superviseView(args, await startedKit()))

package/src/plans/current-phase.ts

@@ -1,4 +1,10 @@
-import { isTickedUnmerged, type LaneProgress, type PhaseProgress, type PlansByHref } from '../plan-format'
+import {
+  isTickedUnmerged,
+  type LaneProgress,
+  type PhaseProgress,
+  type PlanPhase,
+  type PlansByHref,
+} from '../plan-format'
 
 /** A phase of a plan, as the sprint table spells the plan's link. */
 export type PhaseRef = { planHref: string; phaseId: string }
@@ -21,6 +27,20 @@ export const activityKey = (planHref: string, phaseId: string): string => `${pla
 /** Marks a tick string of the tasks alone; one remembered before, with the review gate in it, has no mark. */
 const TASK_TICKS = 't:'
 
+const keptTicks = new WeakMap<PlanPhase, string>()
+
+/** The tick string of a phase's tasks, kept per phase object: a plan that did not change hands back the same phases. */
+const taskTicksOf = (phase: PlanPhase): string => {
+  const kept = keptTicks.get(phase)
+  if (kept !== undefined) return kept
+  const ticks = `${TASK_TICKS}${phase.items
+    .filter((item) => !item.gate)
+    .map((item) => (item.done ? '1' : '0'))
+    .join('')}`
+  keptTicks.set(phase, ticks)
+  return ticks
+}
+
 /**
  * The ticks of each phase's tasks outside the review gate (D67): ticking the gate is bookkeeping, not work on the
  * phase, so it moves nothing in the herd.
@@ -29,15 +49,7 @@ export const tickSnapshotOf = (plans: PlansByHref): TickSnapshot =>
   Object.fromEntries(
     Object.entries(plans).map(([href, phases]) => [
       href,
-      Object.fromEntries(
-        phases.map((phase) => [
-          phase.id,
-          `${TASK_TICKS}${phase.items
-            .filter((item) => !item.gate)
-            .map((item) => (item.done ? '1' : '0'))
-            .join('')}`,
-        ]),
-      ),
+      Object.fromEntries(phases.map((phase) => [phase.id, taskTicksOf(phase)])),
     ]),
   )
 

package/src/plans/current-task.ts

@@ -1,4 +1,4 @@
-import { parseLogEntry } from '../context/session-log'
+import { keptLogEntry } from '../context/session-log'
 import type { PlanPhase } from '../plan-format'
 import { isRecord } from '../shared/is-record'
 
@@ -64,6 +64,21 @@ const TASK_TEXT_LENGTH = 200
 
 const wordsOf = (text: string): Set<string> => new Set(text.toLowerCase().match(WORD) ?? [])
 
+/** How many task texts keep their words: every open task of the plans a herd shows, a few thousand at most. */
+const KEPT_TASK_WORDS = 8192
+
+const taskWords = new Map<string, string[]>()
+
+/** The distinctive words of a task's text (its first `TASK_TEXT_LENGTH` characters), kept per text across refreshes. */
+const taskWordsOf = (text: string): string[] => {
+  const kept = taskWords.get(text)
+  if (kept) return kept
+  const words = [...wordsOf(text.slice(0, TASK_TEXT_LENGTH))]
+  if (taskWords.size >= KEPT_TASK_WORDS) taskWords.clear()
+  taskWords.set(text, words)
+  return words
+}
+
 /**
  * The signal each phase gets from what an agent of the lane did lately (`activity`, see `activityTextOf`): the open
  * task of which the agent used at least `SIGNAL_SHARE` of the distinctive words (six letters or more, from the first
@@ -77,7 +92,7 @@ export const taskSignalsOf = (plan: readonly TaskPhase[], activity: string, at:
   return plan.flatMap((phase) => {
     const scored = phase.items.flatMap((item, taskIndex) => {
       if (item.done) return []
-      const words = [...wordsOf(item.text.slice(0, TASK_TEXT_LENGTH))]
+      const words = taskWordsOf(item.text)
       const hits = words.filter((word) => used.has(word)).length
       return words.length > 0 && hits >= SIGNAL_MIN_WORDS && hits / words.length >= SIGNAL_SHARE
         ? [{ taskIndex, hits }]
@@ -103,7 +118,7 @@ export const activityTextOf = (lines: readonly string[], entries: number): strin
   lines
     .slice(-entries)
     .flatMap((line) => {
-      const message = parseLogEntry(line)?.message
+      const message = keptLogEntry(line)?.message
       return isRecord(message) ? contentTexts(message.content) : []
     })
     .join(' ')

package/src/plans/frame.ts

@@ -1,4 +1,4 @@
-import { paint, visibleLength } from '../terminal/text'
+import { visibleLength } from '../terminal/text'
 import { focusLine, isFocused } from './row-focus'
 import type { ClickTarget, Selection } from './selection'
 
@@ -11,10 +11,6 @@ export type Frame = { lines: string[]; cursorLine: number; targets: ClickTarget[
 /** What goes in front of a frame's lines: `first` on its first line, `rest` on the others, both drawn in `style`. */
 export type Lead = { first: string; rest: string; style: (text: string) => string }
 
-/** The tree lines: a branch to a sibling that has more below it, the last branch, and what carries on beside them. */
-export const TREE = { branch: '├─ ', last: '└─ ', pipe: '│  ', gap: '   ', trunk: '│' } as const
-const TREE_GUTTER = TREE.branch.length
-
 export const textFrame = (lines: string[]): Frame => ({ lines, cursorLine: -1, targets: [] })
 
 /** Stacks frames, moving each one's cursor line and click targets below the frames before it. */
@@ -48,30 +44,26 @@ export const prefixed = (frame: Frame, { first, rest, style }: Lead): Frame => {
   }
 }
 
-/** The context of the children of a node: the pane minus the tree lines in front of them. */
-export const deeper = <Context extends { width: number }>(context: Context): Context => ({
+/** The text as it is: the style of a lead of blanks. */
+export const unpainted = (text: string): string => text
+
+/** The frame moved right by `lead` on every line; the caller has drawn it that much narrower (`narrower`). */
+export const indented = (frame: Frame, lead: string): Frame =>
+  prefixed(frame, { first: lead, rest: lead, style: unpainted })
+
+/** The context `cells` narrower, one cell at the least. */
+export const narrower = <Context extends { width: number }>(context: Context, cells: number): Context => ({
   ...context,
-  width: Math.max(context.width - TREE_GUTTER, 1),
+  width: Math.max(context.width - cells, 1),
 })
 
-const branches = (children: Frame[]): Frame[] => {
-  const present = children.filter((child) => child.lines.length > 0)
-  return present.map((child, index) => {
-    const last = index === present.length - 1
-    return prefixed(child, {
-      first: last ? TREE.last : TREE.branch,
-      rest: last ? TREE.gap : TREE.pipe,
-      style: paint.dim,
-    })
-  })
-}
-
-/**
- * The children of a node as a tree: each child's first line behind a branch, the last behind the closing one, the
- * lines of a child after its first beside the trunk. The caller has drawn the children `TREE_GUTTER` narrower
- * (`deeper`); a child without lines leaves no branch.
- */
-export const nest = (children: Frame[]): Frame => joinFrames(branches(children))
+/** The frames with a blank line between neighbours; a frame without lines takes no line and no blank. */
+export const spaced = (frames: Frame[]): Frame =>
+  joinFrames(
+    frames
+      .filter((frame) => frame.lines.length > 0)
+      .flatMap((frame, index) => (index === 0 ? [frame] : [textFrame(['']), frame])),
+  )
 
 /**
  * A selectable row: drawn with the focus background and mark (`focusLine`) when selected or under the mouse, clickable

package/src/plans/git.ts

@@ -1,13 +1,25 @@
 import { existsSync, readdirSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
 import type { LaneStatus } from './layout'
+import { createProcessSlots } from './process-slots'
 import type { BaseRefInfo } from './sprint-page'
+import type { BranchStatus } from './status-pace'
 
-const gitAsync = async (cwd: string, args: string[]): Promise<string | null> => {
-  const child = Bun.spawn(['git', '-C', cwd, ...args], { stdout: 'pipe', stderr: 'ignore' })
-  const [output, exitCode] = await Promise.all([new Response(child.stdout).text(), child.exited])
-  return exitCode === 0 ? output.trim() : null
-}
+/** How many git processes the herd's reads keep in flight; more end together and hold the event loop as one block. */
+const GIT_PROCESSES = 6
+
+const gitSlots = createProcessSlots(GIT_PROCESSES)
+
+const passAtOnce = async () => {}
+
+/** `pass` is awaited in the slot right before the process starts: starting one holds the event loop as well. */
+const gitAsync = (cwd: string, args: string[], pass: () => Promise<void> = passAtOnce): Promise<string | null> =>
+  gitSlots.run(async () => {
+    await pass()
+    const child = Bun.spawn(['git', '-C', cwd, ...args], { stdout: 'pipe', stderr: 'ignore' })
+    const [output, exitCode] = await Promise.all([new Response(child.stdout).text(), child.exited])
+    return exitCode === 0 ? output.trim() : null
+  })
 
 const git = (cwd: string, args: string[]): string | null => {
   const result = Bun.spawnSync(['git', '-C', cwd, ...args], { stdout: 'pipe', stderr: 'pipe' })
@@ -32,8 +44,25 @@ export const showAtRef = (root: string, ref: string, path: string): string | nul
 export const commitOf = (root: string, ref: string): string | null =>
   git(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`])
 
-const lastChangeAt = (root: string, commit: string, path: string): number | null => {
-  const seconds = Number(git(root, ['log', '-1', '--format=%ct', commit, '--', path]))
+/** The commit `ref` points at, read without holding the event loop; null when it does not exist. */
+export const resolveCommit = async (root: string, ref: string): Promise<string | null> =>
+  (await gitAsync(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`])) || null
+
+/**
+ * The commit of every ref under `namespace` (e.g. `refs/jackherd/pr`), by full ref name, read in one git call and
+ * without holding the event loop; empty when there is none or no git.
+ */
+export const refCommits = async (root: string, namespace: string): Promise<Map<string, string>> => {
+  const output = await gitAsync(root, ['for-each-ref', '--format=%(refname) %(objectname)', namespace])
+  const pairs = (output ?? '').split('\n').flatMap((line) => {
+    const [ref, commit] = line.split(' ')
+    return ref && commit ? [[ref, commit] as const] : []
+  })
+  return new Map(pairs)
+}
+
+const lastChangeAt = async (root: string, commit: string, path: string): Promise<number | null> => {
+  const seconds = Number(await gitAsync(root, ['log', '-1', '--format=%ct', commit, '--', path]))
   return Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : null
 }
 
@@ -51,20 +80,21 @@ const changesOf = (root: string, commit: string): Map<string, number | null> =>
 }
 
 /**
- * A reader of the commit time, in epoch milliseconds, of the last commit at `ref` that changed a path; null when the
- * ref or the file is unknown there. The commit is resolved once per reader and each answer is kept per commit, so a
- * refresh while the ref stands costs one `git rev-parse`, and a moved ref reads afresh.
+ * A reader of the commit time, in epoch milliseconds, of the last commit at `commit` that changed each of `paths`;
+ * null for a path not asked, a file unknown there or no commit. The times not kept yet are read side by side without
+ * holding the event loop, and each answer is kept per commit, so a refresh while the ref stands asks git nothing and
+ * a moved ref reads afresh.
  */
-export const lastChangeReaderOf = (root: string, ref: string): ((path: string) => number | null) => {
-  const commit = commitOf(root, ref)
+export const lastChangesAt = async (
+  root: string,
+  commit: string | null,
+  paths: readonly string[],
+): Promise<(path: string) => number | null> => {
   if (commit === null) return () => null
   const changes = changesOf(root, commit)
-  return (path) => {
-    if (changes.has(path)) return changes.get(path) ?? null
-    const at = lastChangeAt(root, commit, path)
-    changes.set(path, at)
-    return at
-  }
+  const missing = paths.filter((path) => !changes.has(path))
+  await Promise.all(missing.map(async (path) => changes.set(path, await lastChangeAt(root, commit, path))))
+  return (path) => changes.get(path) ?? null
 }
 
 /** Reads files as they are at the base ref. */
@@ -92,8 +122,10 @@ const textsOf = (root: string, commit: string): Map<string, string> => {
  * one `git rev-parse` per ref instead of one `git show` per plan, and the base and the pull request heads read in
  * the same round do not evict each other.
  */
-export const baseReaderOf = (root: string, ref: string): BaseReader => {
-  const commit = commitOf(root, ref)
+export const baseReaderOf = (root: string, ref: string): BaseReader => baseReaderAt(root, commitOf(root, ref))
+
+/** `baseReaderOf` for a commit resolved beforehand (`resolveCommit`); reads nothing without one. */
+export const baseReaderAt = (root: string, commit: string | null): BaseReader => {
   if (commit === null) return () => null
   const texts = textsOf(root, commit)
   return (path) => {
@@ -127,26 +159,53 @@ export const worktreeRoot = (cwd: string): string => {
   return top
 }
 
+const BRANCH_HEAD = '# branch.head '
+const DETACHED_HEAD = '(detached)'
+const HEADER_MARK = '#'
+
 /**
- * Branch, commits ahead of `baseRef` and changed files of a worktree; null and 0 when it does not exist. The three
- * git calls run side by side and without holding the event loop, so a key pressed meanwhile is answered at once.
+ * The branch and the number of changed files, untracked ones included, in the output of `git status --porcelain=v2
+ * --branch`; a detached head and a missing output have no branch.
+ */
+export const branchStatusOf = (output: string | null): BranchStatus => {
+  const lines = (output ?? '').split('\n').filter(Boolean)
+  const head = lines.find((line) => line.startsWith(BRANCH_HEAD))?.slice(BRANCH_HEAD.length)
+  return {
+    branch: head && head !== DETACHED_HEAD ? head : null,
+    dirty: lines.filter((line) => !line.startsWith(HEADER_MARK)).length,
+  }
+}
+
+/** Reads branch and changed files of a worktree; its git process starts after `pass`. */
+export type BranchStatusReader = (worktree: string, pass: () => Promise<void>) => Promise<BranchStatus>
+
+/**
+ * Branch and changed files of a worktree from `git status`, the dearest of the herd's git calls in a large checkout.
+ * Without optional locks: the herd never rewrites the index, which would take the lock an agent's git needs and move
+ * the index the worktree's stamp watches (`worktreeStamp`).
+ */
+export const branchStatusAt: BranchStatusReader = async (worktree, pass) =>
+  branchStatusOf(await gitAsync(worktree, ['--no-optional-locks', 'status', '--porcelain=v2', '--branch'], pass))
+
+/**
+ * Branch, commits ahead of `baseRef` and changed files of a worktree; null and 0 when it does not exist. The two
+ * git calls run side by side and without holding the event loop, so a key pressed meanwhile is answered at once;
+ * each starts after `pass` (a `SliceGate`), so the starts of many worktrees' calls do not add up to one block.
+ * `readBranchStatus` may answer from what it kept instead of asking git (`pacedStatus`).
  */
 export const gitStatusOf = async (
   worktree: string,
   baseRef: string,
+  pass: () => Promise<void> = passAtOnce,
+  readBranchStatus: BranchStatusReader = branchStatusAt,
 ): Promise<Pick<LaneStatus, 'branch' | 'ahead' | 'dirty'>> => {
   if (!existsSync(worktree)) return { branch: null, ahead: null, dirty: 0 }
-  const [count, porcelain, branch] = await Promise.all([
-    gitAsync(worktree, ['rev-list', '--count', `${baseRef}..HEAD`]),
-    gitAsync(worktree, ['status', '--porcelain']),
-    gitAsync(worktree, ['branch', '--show-current']),
+  const [count, status] = await Promise.all([
+    gitAsync(worktree, ['rev-list', '--count', `${baseRef}..HEAD`], pass),
+    readBranchStatus(worktree, pass),
   ])
   const ahead = Number.parseInt(count ?? '', 10)
-  return {
-    branch: branch || null,
-    ahead: Number.isNaN(ahead) ? null : ahead,
-    dirty: (porcelain ?? '').split('\n').filter(Boolean).length,
-  }
+  return { ...status, ahead: Number.isNaN(ahead) ? null : ahead }
 }
 
 /** Where this clone keeps `FETCH_HEAD`, whether it exists yet or not; null outside a git checkout. */