jackherd 1.15.2 → 1.17.0

package/src/plans/layout.ts

@@ -81,8 +81,10 @@ import {
 import {
   BACKLOG_KEY,
   type ClickTarget,
+  entryBlockHeadKey,
   isBlockFolded,
   isBlockHeadKey,
+  isEntryBlockFolded,
   isLaneOpen,
   isLanesOpen,
   LANES_KEY,
@@ -98,7 +100,17 @@ import {
 import type { SentChip } from './sent-files'
 import { shownWithMore } from './shown-with-more'
 import { askedCheckOf } from './source-asked'
-import { type SourceBlock, type SourceSummary, sourceItems, sourceSummaries } from './source-rows'
+import {
+  entryBlockItems,
+  entryBlockSources,
+  type HerdSource,
+  type SourceBlock,
+  type SourceSummary,
+  sourceItems,
+  sourceMoreKey,
+  sourceSummaries,
+  statusOnly,
+} from './source-rows'
 import { chevronOf, LESS_MARK, NO_AGENT_SYMBOL, statusSymbol, statusWord, TURN_MARK } from './symbols'
 import { BADGE_TEXTS, type BadgeTexts, checksText, foldedChecksText, laneMarkText, TEXTS } from './texts'
 import { paintOfRole, paintOfTone, toneOfRole } from './tones'
@@ -177,14 +189,16 @@ export type OverviewView = {
 
 /**
  * The drawn screen: a fixed header and footer around a body that scrolls; body lines and targets count from the body's
- * top. `yourTurnBlock` and `sourceBlock` are what a click on these blocks is matched against, null while the block is
- * not drawn.
+ * top. `yourTurnBlock`, `entryBlocks` and `sourceBlock` are what a click on these blocks is matched against, null (or
+ * no entry block) while the block is not drawn.
  */
 export type Screen = {
   header: string[]
   body: Frame
   footer: string[]
   yourTurnBlock: BlockHit | null
+  /** The blocks of the sources that show their entries, in their order under "Your turn". */
+  entryBlocks: BlockHit[]
   sourceBlock: BlockHit | null
   /** Every clickable row by the screen line it starts on (header lines first, then the body unscrolled): what the mouse and the keys land on. */
   focusHits: FocusHit[]
@@ -236,7 +250,14 @@ type BlockHeadParts = Pick<TopBlock, 'name' | 'count' | 'balance' | 'countPaint'
 type BlockStack = { lines: string[]; hits: (BlockHit | null)[] }
 
 /** What every lane of the lanes block is drawn with. */
-type LanesContext = { state: Selection; width: number; badgeTexts: BadgeTexts; taskStyle: TaskStyle }
+type LanesContext = {
+  state: Selection
+  width: number
+  badgeTexts: BadgeTexts
+  taskStyle: TaskStyle
+  /** How a lane's `↳` activity line is drawn: shimmering while the herd does, so its task rests, dim otherwise. */
+  activityStyle: TaskStyle
+}
 
 /** In front of every line of the lanes block under its head. */
 const LANE_INDENT = '  '
@@ -768,6 +789,14 @@ const detailPlacement = (
   return { beside, room: beside ? besideRoom : width - visibleLength(indent) }
 }
 
+/**
+ * Whether the whole head and a detail still stand on one line with `right`. A lane that rests has no bar, only the
+ * padding that aligns its badges with the others; `laneLines` gives that back before it cuts the name.
+ */
+const detailFitsBeside = (head: string, right: string, width: number, indent: string): boolean =>
+  visibleLength(head) + COLUMN_SEPARATOR.length + visibleLength(right) < width &&
+  detailPlacement(head, right, width, indent).beside
+
 /** The summary the snapshot read for the lane, or the one its own steps give. */
 const summaryOf = (view: LaneView): LaneSummary =>
   view.summary ?? laneSummary({ progress: view.progress, phases: {}, activity: {} }, 0)
@@ -791,16 +820,23 @@ const laneRight = (view: LaneView, tallyWidth: number): string => {
 /** The cells of the phase count column, 0 when the pane leaves it out. */
 const tallyWidthOf = ({ phases, tally }: LaneColumns): number => (phases ? tally : 0)
 
-/** A folded lane's marks in the column of `columns.marks`, right before context and bar. */
-const markedRight = (view: LaneView, columns: LaneColumns): string => {
+/** The marks in the column of `columns.marks`, `padOf(right)` cells before the lane's own context and bar. */
+const marksBeforeRight = (view: LaneView, columns: LaneColumns, padOf: (right: string) => number): string => {
   const right = laneRight(view, tallyWidthOf(columns))
   const marks = laneMarks(view)
   if (!marks) return right
   if (columns.right === 0) return padVisible(marks, columns.marks)
-  const pad = ' '.repeat(Math.max(columns.right - visibleLength(right), 0))
-  return `${padVisible(marks, columns.marks)}${COLUMN_SEPARATOR}${pad}${right}`
+  return `${padVisible(marks, columns.marks)}${COLUMN_SEPARATOR}${' '.repeat(padOf(right))}${right}`
 }
 
+/** A folded lane's marks right before context and bar, padded to the widest right column of the pane. */
+const markedRight = (view: LaneView, columns: LaneColumns): string =>
+  marksBeforeRight(view, columns, (right) => Math.max(columns.right - visibleLength(right), 0))
+
+/** `markedRight` without the padding a lane without a bar only has to align its marks with the other lanes'. */
+const markedRightTight = (view: LaneView, columns: LaneColumns): string =>
+  marksBeforeRight(view, columns, (right) => (right ? Math.max(columns.right - visibleLength(right), 0) : 0))
+
 /** The task row below a folded lane's phase row, under the lane's name; none while the lane reports no task. */
 const foldedTaskRow = (view: LaneView, indent: string, width: number, style: TaskStyle): string[] => {
   const phase = headPhase(view)
@@ -825,8 +861,9 @@ const laneLines = (
   const nameStyle = restsFolded(view, open) ? paint.dim : paint.bold
   const cells = padVisible(nameStyle(fit(progress.lane.name, columns.name)), columns.name)
   const head = `${paint.dim(chevronOf(open))} ${symbolCell(status.agent)} ${cells}`
-  const right = open ? laneProgressColumn(view, tallyWidthOf(columns)) : markedRight(view, columns)
   const nameIndent = ' '.repeat(visibleLength(head) - visibleLength(cells))
+  const aligned = open ? laneProgressColumn(view, tallyWidthOf(columns)) : markedRight(view, columns)
+  const right = open || detailFitsBeside(head, aligned, width, nameIndent) ? aligned : markedRightTight(view, columns)
   const { room } = detailPlacement(head, right, width, nameIndent)
   const lines = withDetail(head, laneDetail(view, open, reason, room), right, width, nameIndent)
   return open ? lines : [...lines, ...foldedTaskRow(view, nameIndent, width, taskStyle)]
@@ -903,39 +940,97 @@ const SUBAGENT_ACTIVITY_INDENT = '  '
 /** How long a subagent's name may grow before its action, so a narrow pane cuts the name and keeps the action. */
 const SUBAGENT_NAME_CELLS = 28
 
-/** One dim line of activity behind `indent`, cut to `width`; the cut is made before the paint, on plain text. */
-const activityLine = (indent: string, text: string, width: number): string =>
-  paint.dim(fit(`${indent}${ACTIVITY_MARK} ${text}`, width))
+/** The key of a lane's activity line, flipped in `expanded`. */
+const laneActivityKey = (lane: string): string => `activity>${lane}`
+
+/**
+ * The key of a subagent's activity line, by its label: a subagent that moves up when another ends keeps its own state,
+ * and the key is no child of the lane's, so folding one leaves the other.
+ */
+const subagentActivityKey = (lane: string, label: string): string => `subagent-activity>${lane}>${label}`
+
+/**
+ * One dim line of activity behind `indent`, cut to the pane on plain text before the paint. A cut line is a row: a
+ * click unfolds it over several lines, the text hanging under its first word, and a second click folds it; a line
+ * that fits is no click target.
+ */
+const activityFrame = (
+  key: string,
+  indent: string,
+  text: string,
+  { state, width, style }: { state: Selection; width: number; style: TaskStyle },
+): Frame => {
+  const head = `${indent}${ACTIVITY_MARK} `
+  const cut = textWidth(`${head}${text}`) > width
+  const lines =
+    cut && state.expanded.has(key)
+      ? wrap(text, Math.max(width - textWidth(head), 1)).map((line, index) =>
+          index === 0 ? `${head}${line}` : `${' '.repeat(textWidth(head))}${line}`,
+        )
+      : [fit(`${head}${text}`, width)]
+  const styled = lines.map(style)
+  return cut ? rowFrame(key, styled, [], { state, width }) : textFrame(styled)
+}
 
 /**
  * The last action of a working lane's agent and of each of its running subagents, one dim line each, under the lane
- * line in the column of its children. None while the lane does not work, or without a source for it.
+ * line in the column of its children. None while the lane does not work, or without a source for it. The first
+ * subagent line shimmers when nothing else of the lane does (`leadsSubagent`).
  */
-const activityLines = ({ activity, status }: LaneView, width: number): string[] => {
+const activityFrames = (
+  { activity, status, progress }: LaneView,
+  {
+    activityStyle,
+    leadsSubagent,
+    ...context
+  }: Pick<LanesContext, 'state' | 'width' | 'activityStyle'> & {
+    leadsSubagent: boolean
+  },
+): Frame[] => {
   if (!activity || status.agent !== AGENT_STATUS.working) return []
+  const lane = progress.lane.name
   const indent = ' '.repeat(LANE_HEAD_CELLS)
+  const still = { ...context, style: paint.dim }
   return [
-    ...(activity.lane === null ? [] : [activityLine(indent, activity.lane, width)]),
-    ...activity.subagents.map(({ label, description, line }) =>
-      activityLine(
+    ...(activity.lane === null
+      ? []
+      : [activityFrame(laneActivityKey(lane), indent, activity.lane, { ...context, style: activityStyle })]),
+    ...activity.subagents.map(({ label, description, line }, index) =>
+      activityFrame(
+        subagentActivityKey(lane, label),
         `${indent}${SUBAGENT_ACTIVITY_INDENT}`,
         `${ellipsize(description ?? label, SUBAGENT_NAME_CELLS)}: ${line}`,
-        width,
+        leadsSubagent && index === 0 ? { ...context, style: activityStyle } : still,
       ),
     ),
   ]
 }
 
+/** True when the lane shows its own `↳` activity line: the one line of the lane that shimmers, its task rests. */
+const showsLaneActivity = ({ activity, status }: LaneView): boolean =>
+  typeof activity?.lane === 'string' && status.agent === AGENT_STATUS.working
+
+/** True when a task line of the lane shimmers: the pane shimmers its tasks and the lane reports one to show. */
+const showsShimmeringTask = (
+  view: LaneView,
+  { width, taskStyle }: Pick<LanesContext, 'width' | 'taskStyle'>,
+): boolean => taskStyle === SHIMMERING_TASK && foldedTaskRow(view, '', width, taskStyle).length > 0
+
+/** True when no line of the lane shimmers yet, so its first subagent line does: neither its activity nor its task. */
+const subagentLeads = (view: LaneView, context: Pick<LanesContext, 'width' | 'taskStyle'>): boolean =>
+  !showsLaneActivity(view) && !showsShimmeringTask(view, context)
+
 /**
  * The lane line is a row of its own; an open lane continues after a blank line with its session, links, pull requests
  * and phases (`openLaneFrame`), indented to the column of the lane's name.
  */
 const laneBlock = (
   view: LaneView,
-  { state, width, badgeTexts, taskStyle }: LanesContext,
+  { state, width, badgeTexts, taskStyle: lanesTaskStyle, activityStyle }: LanesContext,
   columns: LaneColumns,
   reason: LaneReason | null,
 ): Frame => {
+  const taskStyle = showsLaneActivity(view) ? STILL_TASK : lanesTaskStyle
   const context: LaneContext = {
     progress: view.progress,
     state,
@@ -950,8 +1045,8 @@ const laneBlock = (
   const open = isLaneOpen(state, view.progress.lane.name, view.status.agent)
   const lines = laneLines(view, open, { width, taskStyle }, columns, reason)
   const lane = rowFrame(laneKey(view.progress.lane.name), lines, [], context)
-  const activity = activityLines(view, width)
-  const row = activity.length > 0 ? joinFrames([lane, textFrame(activity)]) : lane
+  const leadsSubagent = subagentLeads(view, { width, taskStyle: lanesTaskStyle })
+  const row = joinFrames([lane, ...activityFrames(view, { state, width, activityStyle, leadsSubagent })])
   if (!open) return row
   const inner = narrower(context, LANE_HEAD_CELLS)
   const head = {
@@ -1226,11 +1321,12 @@ const sourceSummaryText = (summaries: readonly SourceSummary[]): string =>
  * fails, and a source's entries under it once opened.
  */
 const sourceLines = (
-  { sources, now }: SourceBlock,
+  { sources: listed, now }: SourceBlock,
   awaiting: readonly WaitingItem[],
   state: Selection,
   width: number,
 ): BlockLines => {
+  const sources = listed.map(statusOnly)
   const shown = state.expanded.has(SOURCE_MORE_KEY) ? sources : sources.slice(0, SHOWN_BLOCK_ROWS)
   const asked = askedCheckOf(awaiting)
   const newTone = toneOfRole(TONE_ROLE.new)
@@ -1258,6 +1354,70 @@ const sourceLinesOf = (
 ): BlockLines | null =>
   sourceBlock && sourceBlock.sources.length > 0 ? sourceLines(sourceBlock, awaiting, state, width) : null
 
+/**
+ * How many entry rows all blocks of entries show together while folded: one calendar keeps the five of the other
+ * blocks, a second one takes from the same five, so the head of the herd, which does not scroll, leaves the lanes room.
+ */
+const ENTRY_BLOCK_ROW_BUDGET = SHOWN_BLOCK_ROWS
+
+/**
+ * The rows each block of entries shows while folded, in the order of the sources: the shared budget, with one row kept
+ * for each block after it, and at least one row per block, so a block past the budget still shows its first entry; a
+ * block with fewer entries than its share leaves the rest to the blocks after it. More blocks than the budget take one
+ * row each, past the budget.
+ */
+const entryRowShares = (counts: readonly number[], budget: number): number[] => {
+  let left = budget
+  return counts.map((count, index) => {
+    const share = Math.min(count, Math.max(left - (counts.length - index - 1), 1))
+    left -= share
+    return share
+  })
+}
+
+/** A source with a block of its own, the clock its times are counted against and the rows it shows while folded. */
+type EntryBlock = { source: HerdSource; now: number; share: number }
+
+/**
+ * The block of a source that shows its entries: open at the start, headed by its label (else its name) and the number
+ * of entries, folded and opened again by its head as in the other blocks, its `share` of entries and `+<n>` for the
+ * rest, which opens all of them and folds them again. An entry with an address opens it.
+ */
+const entryBlockLines = ({ source, now, share }: EntryBlock, state: Selection, width: number): BlockLines => {
+  const moreKey = sourceMoreKey(source.name)
+  const expanded = state.expanded.has(moreKey)
+  const hidden = source.entries.length - share
+  const block: TopBlock = {
+    name: source.label ?? source.name,
+    count: source.entries.length,
+    balance: '',
+    markPaint: paint.dim,
+    focused: (key) => isFocused(state, key),
+    allBold: (key) => buttonsAllBold(state, key),
+    countPaint: (text) => text,
+    moreKey: hidden > 0 ? moreKey : null,
+    hidden,
+    expanded,
+    rows: allBlockRows(entryBlockItems(source, now, expanded ? source.entries.length : share), new Set(), width),
+  }
+  const headKey = entryBlockHeadKey(source.name)
+  return isEntryBlockFolded(state, source.name)
+    ? foldedBlockLines(block, headKey, width)
+    : openBlockLines(block, headKey, width)
+}
+
+const entryBlocksOf = (sourceBlock: SourceBlock | undefined, state: Selection, width: number): BlockLines[] => {
+  if (!sourceBlock) return []
+  const sources = entryBlockSources(sourceBlock.sources)
+  const shares = entryRowShares(
+    sources.map(({ entries }) => entries.length),
+    ENTRY_BLOCK_ROW_BUDGET,
+  )
+  return sources.map((source, index) =>
+    entryBlockLines({ source, now: sourceBlock.now, share: shares[index] ?? 0 }, state, width),
+  )
+}
+
 /**
  * The blocks one under the other, `offset` lines below the top of the screen, a blank line after each, so one stands
  * between neighbours and one between the last and the lanes. An absent block (null) takes no line and has no hit.
@@ -1419,6 +1579,7 @@ export const renderScreen = (
   width: number,
 ): Screen => {
   const taskStyle = shimmer ? SHIMMERING_TASK : STILL_TASK
+  const activityStyle = shimmer ? SHIMMERING_TASK : paint.dim
   const { active, waiting, noAgent } = partitionLanes(lanes)
   const badgeTexts = BADGE_TEXTS
   const turnRowsOf = yourTurn ? [...yourTurn.turn.now, ...yourTurn.turn.planned] : []
@@ -1429,9 +1590,13 @@ export const renderScreen = (
   const nowLines = unplaced.map((task) => nowLine(task, width, taskStyle))
   const above = nowLines.length > 0 ? [titleLine, rule(width), ...nowLines] : [titleLine]
   const listed = sourceLinesOf(sourceBlock, awaiting, state, width)
-  const stack = stackBlocks([turn, listed], above.length)
+  const entryBlocks = entryBlocksOf(sourceBlock, state, width)
+  const stack = stackBlocks([turn, ...entryBlocks, listed], above.length)
+  const sourcesSlot = 1 + entryBlocks.length
   const sections = [
-    ...(active.length > 0 ? [lanesFrame(active, turnRowsOf, { state, width, badgeTexts, taskStyle })] : []),
+    ...(active.length > 0
+      ? [lanesFrame(active, turnRowsOf, { state, width, badgeTexts, taskStyle, activityStyle })]
+      : []),
     ...(waiting.length > 0 ? [waitingFrame(waiting, state, width)] : []),
     textFrame(parkedBlock(noAgent, width)),
     ...(planned.length > 0 ? [backlogFrame(planned, state, width)] : []),
@@ -1448,7 +1613,8 @@ export const renderScreen = (
   const body = { ...plainBody, lines: emphasisedAt(plainBody.lines, plainHeader.length, focusHits, state, width) }
   return {
     yourTurnBlock: stack.hits[0],
-    sourceBlock: stack.hits[1],
+    entryBlocks: stack.hits.slice(1, sourcesSlot).filter((hit) => hit !== null),
+    sourceBlock: stack.hits[sourcesSlot],
     focusHits: state.showLegend ? focusHits.filter(({ line }) => line < plainHeader.length) : focusHits,
     rowKeys: [...blockHits.map(({ key }) => key), ...targetKeys(body.targets)],
     header,

package/src/plans/live.ts

@@ -35,6 +35,7 @@ import { REFRESH_PACE } from './refresh-pace'
 import { TAKEN_OVER_CODE, TAKEOVER_SIGNAL } from './restart-decision'
 import { closeRow } from './row-actions'
 import { blockRowByKey, type HoverScreen, hoveredSelection, rehovered, withoutHover } from './row-focus'
+import { DONE_KIND, type DoneTarget } from './row-targets'
 import {
   applyClick,
   inputOutcome,
@@ -46,10 +47,7 @@ import {
   parseMouse,
   splitKeys,
   syncLaneFolds,
-  TOP_BLOCK,
-  type TopBlockId,
   toggledExpansion,
-  topBlockHeadKey,
   type View,
   windowTop,
   withoutStaleMotions,
@@ -76,6 +74,7 @@ import {
   startSelection,
 } from './view'
 import { type BlockClick, type BlockHit, blockClick, blockHeadClick, mainClickOf } from './waiting-click'
+import type { TurnRow, YourTurn } from './your-turn'
 
 /**
  * Where the herd's reads come from: its own reader, or the read the watcher publishes for every herd of the board
@@ -97,6 +96,8 @@ type Live = {
   errors: string[]
   /** One footer line about the last action of the person, such as where the sprint page was written; cleared by the next key. */
   notice: string | null
+  /** What a `[done]` closed, left out of "Your turn" from the click until a read no longer holds its row. */
+  closing: DoneTarget[]
   reported: Map<string, string | null>
   /** The snapshot as read, without the plan chips; `snapshot` is this plus the chips of the page. */
   read: Snapshot | null
@@ -123,6 +124,39 @@ type Live = {
 
 const QUIT_KEYS = new Set(['\x03', 'q'])
 
+/** Whether `row` of "Your turn" is what `target` closes: a record by its id, a board row or an appointment by its cells. */
+const isClosedBy = (target: DoneTarget, { waiting, appointment }: TurnRow): boolean => {
+  switch (target.kind) {
+    case DONE_KIND.record:
+      return waiting?.id === target.id
+    case DONE_KIND.boardRow:
+      return waiting?.id === undefined && waiting?.since === target.since && waiting.item === target.item
+    case DONE_KIND.appointment:
+      return appointment?.when === target.when && appointment.action === target.action
+  }
+}
+
+const isClosing = (closing: readonly DoneTarget[], row: TurnRow): boolean =>
+  closing.some((target) => isClosedBy(target, row))
+
+/** "Your turn" without the rows `closing` names, so a closed row leaves at the click, not at the next read. */
+export const withoutClosing = (turn: YourTurn, closing: readonly DoneTarget[]): YourTurn => {
+  if (closing.length === 0) return turn
+  const open = (rows: readonly TurnRow[]) => rows.filter((row) => !isClosing(closing, row))
+  return { now: open(turn.now), planned: open(turn.planned) }
+}
+
+/** The closings a read still holds a row of; one whose row the read no longer holds is closed on the board as well. */
+export const pendingClosings = (turn: YourTurn | undefined, closing: readonly DoneTarget[]): DoneTarget[] => {
+  const rows = turn ? [...turn.now, ...turn.planned] : []
+  return closing.filter((target) => rows.some((row) => isClosedBy(target, row)))
+}
+
+const withClosingLeftOut = (snapshot: Snapshot, closing: readonly DoneTarget[]): Snapshot =>
+  snapshot.yourTurn && closing.length > 0
+    ? { ...snapshot, yourTurn: { ...snapshot.yourTurn, turn: withoutClosing(snapshot.yourTurn.turn, closing) } }
+    : snapshot
+
 /** The sidebar titles that differ from the ones last reported, in the order of `titles`; null clears one. */
 export const changedTitles = (
   titles: ReadonlyMap<string, string | null>,
@@ -171,7 +205,7 @@ const renderContextOf = (live: Live): RenderContext => ({
 
 /** The screen for the current state, with the window scrolled to keep the cursor in view. */
 const renderLive = (live: Live, snapshot: Snapshot): { screen: Screen; top: number } => {
-  const screen = renderSnapshot(snapshot, renderContextOf(live))
+  const screen = renderSnapshot(withClosingLeftOut(snapshot, live.closing), renderContextOf(live))
   return { screen, top: windowTop(live.view, screen.body.cursorLine, screen.body.lines.length, bodyRows(screen)) }
 }
 
@@ -236,7 +270,7 @@ const followShimmer = (live: Live, prepared: PreparedShimmer) => {
 const drawHover = (live: Live) => {
   live.frame = null
   if (!live.snapshot) return
-  live.plain ??= renderUnfocused(live.snapshot, renderContextOf(live))
+  live.plain ??= renderUnfocused(withClosingLeftOut(live.snapshot, live.closing), renderContextOf(live))
   const laid = focusedScreen(live.plain, live.view.selection, paneWidth(), agentOfSnapshot(live.snapshot))
   if (laid === null) redraw(live)
   else write(live, laid, live.view.top)
@@ -311,6 +345,7 @@ const takeRead = (live: Live, outcome: ReadOutcome, notes: readonly string[]): b
   )
   live.view = { ...live.view, selection: folded }
   live.snapshot = next
+  live.closing = pendingClosings(next.yourTurn?.turn, live.closing)
   live.errors = [...next.errors, ...notes, ...reportTitles(live.source, next.titles, live.reported)]
   return redraw(live)
 }
@@ -474,12 +509,14 @@ const applyBlockClick = (live: Live, outcome: BlockClick): void => {
     return
   }
   if ('done' in outcome) {
-    live.notice = closeRow(outcome.done, {
+    const { closed, notice } = closeRow(outcome.done, {
       sprintFile: live.source.sprintFile,
       language: live.source.settings.planLanguage,
       now: new Date(),
       closeRecords: (ids) => closeWaiting(live.source.root, ids, Date.now()),
     })
+    if (closed) live.closing = [...live.closing, outcome.done]
+    live.notice = notice
     return
   }
   const reason = openInBrowser(outcome.open)
@@ -487,17 +524,18 @@ const applyBlockClick = (live: Live, outcome: BlockClick): void => {
 }
 
 /**
- * A plain click on a block on top of the herd, matched against `hit` as it was drawn: the head folds or opens it, a
+ * A plain click on a block on top of the herd, matched against `hit` as it was drawn: the head folds or
+ * opens its block, a
  * cut-off row expands, a file or Artifact opens, a button asks the coordinator or closes the row; the failure or the
  * result shows in the footer.
  */
-const clickBlock = (live: Live, block: TopBlockId, hit: BlockHit | null, input: string): boolean => {
+const clickBlock = (live: Live, hit: BlockHit | null, input: string): boolean => {
   const mouse = parseMouse(input)
   if (!mouse || !hit) return false
-  if (blockHeadClick(hit.firstLine - 1, mouse)) {
+  if (hit.headKey && blockHeadClick(hit.firstLine - 1, mouse)) {
     live.view = {
       ...live.view,
-      selection: applyClick(live.view.selection, topBlockHeadKey(block)),
+      selection: applyClick(live.view.selection, hit.headKey),
     }
     return true
   }
@@ -533,7 +571,11 @@ const activateBlockRow = (live: Live, screen: Screen, input: string): boolean =>
   return true
 }
 
-const blocksOf = ({ yourTurnBlock, sourceBlock }: Screen): (BlockHit | null)[] => [yourTurnBlock, sourceBlock]
+const blocksOf = ({ yourTurnBlock, entryBlocks, sourceBlock }: Screen): (BlockHit | null)[] => [
+  yourTurnBlock,
+  ...entryBlocks,
+  sourceBlock,
+]
 
 const handleInput = (live: Live, input: string) => {
   const { snapshot, screen } = live
@@ -543,7 +585,6 @@ const handleInput = (live: Live, input: string) => {
     hover(live, screen, mouse)
     return
   }
-  live.notice = null
   const settled = settledSelection(live.view.selection, screen)
   live.view = { ...live.view, selection: mouse ? settled : withoutHover(settled) }
   if (activateBlockRow(live, screen, input)) {
@@ -555,8 +596,9 @@ const handleInput = (live: Live, input: string) => {
     return
   }
   if (
-    clickBlock(live, TOP_BLOCK.yourTurn, screen.yourTurnBlock, input) ||
-    clickBlock(live, TOP_BLOCK.sources, screen.sourceBlock, input)
+    clickBlock(live, screen.yourTurnBlock, input) ||
+    screen.entryBlocks.some((hit) => clickBlock(live, hit, input)) ||
+    clickBlock(live, screen.sourceBlock, input)
   ) {
     redraw(live)
     return
@@ -594,6 +636,7 @@ export const runLive = (source: Source, key: string | null = null): void => {
     view: { selection: overviewSelection(), top: 0, follow: true },
     errors: [],
     notice: null,
+    closing: [],
     reported: new Map(),
     read: null,
     whole: null,

package/src/plans/plan-panes.ts

@@ -35,6 +35,14 @@ export type PlanPaneResult = { actions: PaneAction[]; notes: string[] }
 
 type ListedPane = { pane_id: string; tab_id: string; cwd: string; agent?: unknown; label?: unknown }
 
+/**
+ * The exit codes of `herd --ensure`: `noCoordinator` when the coordinator's pane is missing or ambiguous, so a
+ * caller that runs it after a restart knows to wait for the coordinator's session; 1 stays the error of the CLI.
+ */
+export const ENSURE_EXIT = { done: 0, noCoordinator: 3 } as const
+
+export type EnsureExit = (typeof ENSURE_EXIT)[keyof typeof ENSURE_EXIT]
+
 const isListedPane = (value: unknown): value is ListedPane => {
   if (typeof value !== 'object' || value === null) return false
   const candidate = value as Record<string, unknown>
@@ -124,9 +132,13 @@ export const isIdleShell = ({ agent, foreground }: PaneState): boolean =>
 const isStartingShell = ({ agent, foreground }: PaneState): boolean =>
   !agent && (foreground.length === 0 || SHELLS.has(programOf(foreground[0])))
 
+const hasHerdBeside = (panes: readonly PaneState[], agent: PaneState): boolean =>
+  panes.some((each) => each.tab === agent.tab && each.label === herdLabel(null))
+
 /**
  * The coordinator's pane: the agent herdr lists under the coordinator's name, else the calling pane when an agent
- * in the main checkout runs there, else the only agent in the main checkout. Two agents there and no name: none.
+ * in the main checkout runs there, else the only agent in the main checkout, else the only one there whose tab holds
+ * a pane labelled `herd` (herdr keeps labels across a restart, agent names not always). Otherwise none.
  */
 export const coordinatorPaneOf = (
   panes: readonly PaneState[],
@@ -136,15 +148,20 @@ export const coordinatorPaneOf = (
   if (hints.named) return hints.named
   const inRoot = panes.filter((each) => each.agent && each.cwd === root)
   if (hints.caller && inRoot.some((each) => each.pane === hints.caller)) return hints.caller
-  return inRoot.length === 1 ? (inRoot[0]?.pane ?? null) : null
+  const candidates = inRoot.length === 1 ? inRoot : inRoot.filter((agent) => hasHerdBeside(panes, agent))
+  return candidates.length === 1 ? (candidates[0]?.pane ?? null) : null
 }
 
-/** Why no coordinator pane was found: no agent in the main checkout, or several and none of them named. */
+/** The exit code of `herd --ensure` for the coordinator pane it found among `panes`, or none. */
+export const ensureExitOf = (panes: readonly PaneState[], coordinator: string | null): EnsureExit =>
+  panes.some((each) => each.pane === coordinator) ? ENSURE_EXIT.done : ENSURE_EXIT.noCoordinator
+
+/** Why no coordinator pane was found: no agent in the main checkout, or several, none named and none alone beside a herd pane. */
 export const missingCoordinatorNote = (panes: readonly PaneState[], root: string, name: string): string => {
   const inRoot = panes.filter((each) => each.agent && each.cwd === root).length
   return inRoot === 0
     ? 'coordinator: no agent in the main checkout'
-    : `coordinator: ${inRoot} agents in the main checkout and none named ${name}; run herd --ensure in its pane, or herdr agent rename <pane> ${name}`
+    : `coordinator: ${inRoot} agents in the main checkout, none named ${name} and none alone beside a herd pane; run herd --ensure in its pane, or herdr agent rename <pane> ${name}`
 }
 
 const quoted = (arg: string): string => (/^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`)

package/src/plans/row-actions.ts

@@ -16,9 +16,16 @@ export type CloseDependencies = {
   closeRecords: (ids: readonly string[]) => number
 }
 
-const closeRecord = (id: string, { closeRecords }: CloseDependencies): string => {
-  if (!isQuestionId(id)) return TEXTS.notClosed('not a record id')
-  return closeRecords([id]) > 0 ? TEXTS.closed(`record ${id}`) : TEXTS.notClosed('record not found or closed already')
+/** Whether the row was closed, and the footer line that says so or why not. */
+export type CloseResult = { closed: boolean; notice: string }
+
+const closedAs = (subject: string): CloseResult => ({ closed: true, notice: TEXTS.closed(subject) })
+
+const notClosed = (reason: string): CloseResult => ({ closed: false, notice: TEXTS.notClosed(reason) })
+
+const closeRecord = (id: string, { closeRecords }: CloseDependencies): CloseResult => {
+  if (!isQuestionId(id)) return notClosed('not a record id')
+  return closeRecords([id]) > 0 ? closedAs(`record ${id}`) : notClosed('record not found or closed already')
 }
 
 const closedBoard = (target: DoneTarget, board: string, { language, now }: CloseDependencies): string | null => {
@@ -31,22 +38,22 @@ const subjectOfRow = (target: DoneTarget): string => {
   return target.kind === DONE_KIND.appointment ? `appointment ${boardRowKey(target.when, target.action)}` : ''
 }
 
-const closeBoardRow = (target: DoneTarget, dependencies: CloseDependencies): string => {
+const closeBoardRow = (target: DoneTarget, dependencies: CloseDependencies): CloseResult => {
   try {
     const board = readFileSync(dependencies.sprintFile, 'utf8')
     const closed = closedBoard(target, board, dependencies)
-    if (closed === null) return TEXTS.notClosed('row not found in the board')
+    if (closed === null) return notClosed('row not found in the board')
     writeFileSync(dependencies.sprintFile, closed)
-    return TEXTS.closed(subjectOfRow(target))
+    return closedAs(subjectOfRow(target))
   } catch (error) {
-    return TEXTS.notClosed(errorText(error))
+    return notClosed(errorText(error))
   }
 }
 
 /**
  * Closes what a `[done]` button names: a log record by its id, or a row of the board's file by writing the stamp into its
- * status cell. Returns the footer line. The board is read again just before it is written, so a row the coordinator
- * changed since the herd drew it is found by its text or not at all.
+ * status cell. Returns whether it closed and the footer line. The board is read again just before it is written, so a
+ * row the coordinator changed since the herd drew it is found by its text or not at all.
  */
-export const closeRow = (target: DoneTarget, dependencies: CloseDependencies): string =>
+export const closeRow = (target: DoneTarget, dependencies: CloseDependencies): CloseResult =>
   target.kind === DONE_KIND.record ? closeRecord(target.id, dependencies) : closeBoardRow(target, dependencies)