jackherd 1.11.2 → 1.12.0

package/src/plans/legend.ts

@@ -0,0 +1,29 @@
+import { fit, padVisible, paint, visibleLength } from '../terminal/text'
+
+/** One line of the help: a mark or a key, then what it means. */
+export type LegendEntry = { mark: string; meaning: string }
+
+/** A section of the help under its title. */
+export type LegendSection = { title: string; entries: LegendEntry[] }
+
+/** The blanks before every entry and between its mark and its meaning. */
+const ENTRY_INDENT = '  '
+const COLUMN_GAP = '  '
+
+const sectionLines = ({ title, entries }: LegendSection, width: number): string[] => {
+  const markWidth = Math.max(0, ...entries.map(({ mark }) => visibleLength(mark)))
+  return [
+    fit(paint.bold(title), width),
+    ...entries.map(({ mark, meaning }) =>
+      fit(`${ENTRY_INDENT}${padVisible(mark, markWidth)}${COLUMN_GAP}${meaning}`, width),
+    ),
+  ]
+}
+
+/**
+ * The help as lines: each section under its bold title, one entry per line in two columns (the marks of a section
+ * padded to its widest, so every meaning starts in one column), cut at the pane rather than wrapped; a blank line
+ * between the sections.
+ */
+export const legendLines = (sections: readonly LegendSection[], width: number): string[] =>
+  sections.flatMap((section, index) => [...(index > 0 ? [''] : []), ...sectionLines(section, width)])

package/src/plans/link-chips.ts

@@ -7,7 +7,7 @@ type Found = { url: string; text: string | null; before: string; line: string }
 
 const MARKDOWN_LINK = /\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g
 const AUTOLINK = /<(https?:\/\/[^>\s]+)>/g
-const BARE_LINK = /(?<![(<\w"])(https?:\/\/[^\s)>\]]+)/g
+const BARE_LINK = /(?<![<\w"])(https?:\/\/[^\s)>\]]+)/g
 const LABEL_BEFORE = /\*\*([^*]+?):?\*\*:?\s*(?:[-–>]\s*)?$/
 const PRIVATE = /\bprivat/i
 const MARKS = /\*\*|`/g
@@ -29,7 +29,7 @@ const linksOf = (line: string): Found[] => {
 
 const LIST_LEAD = /^\s*(?:[-*>]\s*)*(?:\[[ xX]\]\s*)?/
 const LEFTOVER_LINK = /\bhttps?:\/\/\S+/g
-const TITLE_END = /[\s:,;.\-–>]+$/
+const TITLE_END = /[\s:,;.\-–>(]+$/
 
 /** What a line says besides its links, without list marks, checkbox and emphasis: the title of a bare artifact link. */
 const lineTitleOf = ({ line }: Found): string =>
@@ -50,12 +50,13 @@ const labelOf = (found: Found, kind: LinkKind): string => {
   return (kind.pattern === ARTIFACT_LINK_KIND.pattern && lineTitleOf(found)) || kind.label
 }
 
-/**
- * The links of a plan's text that match one of the kinds, once each and in the order they appear. The chip's
- * text is the link text, else the bold label written before the link (`**Mockup:** <url>`), else the kind's
- * label; a link on a line that says it is private carries that. Nothing is fetched.
- */
-export const extractLinkChips = (markdown: string, kinds: readonly LinkKind[]): LinkChip[] => {
+/** How many texts the chips are kept for, per list of kinds; the kept ones are dropped all at once when they are too many. */
+const KEPT_TEXTS = 200
+
+const keptChips = new WeakMap<readonly LinkKind[], Map<string, LinkChip[]>>()
+
+/** `extractLinkChips` without its cache, for a reader that goes through more texts than the cache keeps. */
+export const readLinkChips = (markdown: string, kinds: readonly LinkKind[]): LinkChip[] => {
   const compiled = kinds.map((kind) => ({ kind, pattern: new RegExp(kind.pattern) }))
   const chips = new Map<string, LinkChip>()
   for (const line of markdown.split('\n')) {
@@ -73,6 +74,23 @@ export const extractLinkChips = (markdown: string, kinds: readonly LinkKind[]):
   return [...chips.values()]
 }
 
+/**
+ * The links of a plan's text that match one of the kinds, once each and in the order they appear. The chip's
+ * text is the link text, else the bold label written before the link (`**Mockup:** <url>`), else the kind's
+ * label; a link on a line that says it is private carries that. Nothing is fetched. The chips are kept per text
+ * and list of kinds, so a refresh and lanes sharing a plan get the same array back: callers must not change it.
+ */
+export const extractLinkChips = (markdown: string, kinds: readonly LinkKind[]): LinkChip[] => {
+  const byText = keptChips.get(kinds) ?? new Map<string, LinkChip[]>()
+  keptChips.set(kinds, byText)
+  const kept = byText.get(markdown)
+  if (kept) return kept
+  if (byText.size >= KEPT_TEXTS) byText.clear()
+  const chips = readLinkChips(markdown, kinds)
+  byText.set(markdown, chips)
+  return chips
+}
+
 const CHIP_KEY = /^chip>(https?:\/\/.+)$/
 const PLAN_KEY = /^plan>(file:\/\/\/.+)$/
 

package/src/plans/live.ts

@@ -1,12 +1,11 @@
-import { existsSync, type FSWatcher, watch } from 'node:fs'
+import { existsSync, type FSWatcher, statSync, watch, writeSync } from 'node:fs'
 import { basename, dirname } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { terminalSafe } from '../plan-format/terminal-text'
 import { runHerdr } from '../terminal/herdr'
 import { openInBrowser } from '../terminal/open'
-import { stripAnsi } from '../terminal/text'
+import { crashEnd, onceRestore } from '../terminal/restore'
 import { closeWaiting } from '../waiting/command'
-import { appointmentKeys } from './appointment-rows'
 import { askCoordinator } from './ask-coordinator'
 import type { LaneMemory } from './current-phase'
 import { errorText } from './error-text'
@@ -24,16 +23,17 @@ import { fetchHeadPath } from './git'
 import { fetchPullRequests, noPullRequests, type PullRequestState } from './github'
 import { recallLanes, rememberLanes } from './herd-memory'
 import { type Screen, settledSelection } from './layout'
-import { nextKeys } from './next-rows'
 import { type KnownPage, pageAfterWrite, pageKey, pageNeedsWriting, planAnchorOn, withPlanChips } from './plan-chips'
 import { planPullRequests } from './plan-heads'
 import { herdLabel } from './plan-panes'
 import { pullRequestUrl } from './pull-requests'
 import { newReadCache, type ReadCache } from './read-cache'
+import { quietRoundsAfter, REFRESH_PACE, refreshDelay } from './refresh-pace'
 import { TAKEN_OVER_CODE, TAKEOVER_SIGNAL } from './restart-decision'
 import { closeRow } from './row-actions'
-import { blockRowByKey, bracketAt, hoveredKeyAt, lineIndexAt, withHovered } from './row-focus'
+import { blockRowByKey, type HoverScreen, hoveredSelection, rehovered, withoutHover } from './row-focus'
 import {
+  applyClick,
   inputOutcome,
   isActivateKey,
   isMotion,
@@ -41,35 +41,42 @@ import {
   type MouseEvent,
   overviewSelection,
   parseMouse,
-  settledBlockFolds,
-  showDoneNotice,
   splitKeys,
   syncLaneFolds,
   TOP_BLOCK,
   type TopBlockId,
-  toggledBlockFold,
   toggledExpansion,
+  topBlockHeadKey,
   type View,
   windowTop,
+  withoutStaleMotions,
 } from './selection'
 import { BASE_REMOTE, baseRefOf, boardRepoPathOf, CLOCK_LOCALE } from './settings'
+import { SHIMMER, shimmerEnabled, shimmerRows } from './shimmer'
 import { singleFlight } from './single-flight'
 import { loadSnapshot, type Snapshot, type Source } from './snapshot'
-import { sourceKeys } from './source-rows'
 import { exportSprintPage, writeSprintPageInSteps } from './sprint-export'
 import { boardTexts } from './texts'
 import {
+  agentOfSnapshot,
   bodyRows,
+  changedLinesOutput,
   clockOf,
-  frameOutput,
-  frameToWrite,
+  focusedScreen,
+  frameLinesOf,
+  nextFrameDelay,
+  type PreparedShimmer,
   paneWidth,
+  preparedShimmer,
   renderSnapshot,
+  renderUnfocused,
+  shimmerOutput,
   startSelection,
   TERMINAL_OFF,
   TERMINAL_ON,
 } from './view'
-import { type BlockClick, type BlockHit, blockClick, blockHeadClick, mainClickOf, waitingKeys } from './waiting-click'
+import { type BlockClick, type BlockHit, blockClick, blockHeadClick, mainClickOf } from './waiting-click'
+import { isOwnFetchWrite, watchRefreshDelay } from './watch-burst'
 
 /** The state of the running view; only the functions below `runLive` change it. */
 type Live = {
@@ -97,16 +104,40 @@ type Live = {
   page: KnownPage | null
   pageWriting: boolean
   flight: (() => Promise<void>) | null
+  /** The refreshes in a row that wrote nothing to the terminal; the next one waits `refreshDelay` of it. */
+  quietRounds: number
+  /** When the last refresh started (epoch milliseconds), null before the first; a refresh outside the pace waits `watchRefreshDelay` of it. */
+  lastRefreshAt: number | null
   pageError: string | null
-  /** The frame last written to the terminal; null while its content is unknown, such as after a resize. */
-  written: string | null
+  /**
+   * The lines last written to the terminal, with their shimmer marks, so a stripe that moved on is no change (the
+   * shimmer clock draws that); null while the terminal content is unknown, such as after a resize.
+   */
+  written: string[] | null
+  /** The current state drawn with no row focused, which a hover lays its focus on; null until a hover needs it. */
+  plain: Screen | null
+  /** The last mouse motion, so a new frame finds the row under a mouse that did not move; null before the first. */
+  mouse: MouseEvent | null
+  /** When the last frame was drawn (epoch milliseconds), null before the first; a hover draws at most once per frame time. */
+  lastFrameAt: number | null
+  /** The drawing a hover asked for, while it waits for the frame time. */
+  frame: Timer | null
+  /** The rows of the frame on the terminal that shimmer, prepared, and the clock that redraws them; null while none does. */
+  shimmer: { prepared: PreparedShimmer; clock: Timer | null }
 }
 
-const REFRESH_MS = 5_000
 const PULL_REQUEST_REFRESH_MS = 60_000
-const DEBOUNCE_MS = 150
 const QUIT_KEYS = new Set(['\x03', 'q'])
 
+/** When `file` was last written (epoch milliseconds); 0 when it cannot be stat-ed, which no fetch of the herd claims. */
+const modifiedAt = (file: string): number => {
+  try {
+    return statSync(file).mtimeMs
+  } catch {
+    return 0
+  }
+}
+
 /** 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>,
@@ -130,7 +161,7 @@ const clearTitles = (source: Source, reported: Map<string, string | null>) => {
   }
 }
 
-const syncWatchers = (watchers: Map<string, FSWatcher>, files: string[], onChange: () => void) => {
+const syncWatchers = (watchers: Map<string, FSWatcher>, files: string[], onChange: (file: string) => void) => {
   for (const [file, watcher] of watchers) {
     if (files.includes(file)) continue
     watcher.close()
@@ -143,44 +174,156 @@ const syncWatchers = (watchers: Map<string, FSWatcher>, files: string[], onChang
           watcher.close()
           watchers.delete(file)
         }
-        onChange()
+        onChange(file)
       })
       watchers.set(file, watcher)
     } catch {
-      // A file that cannot be watched right now is retried on the next refresh; the 5 s refresh covers it meanwhile.
+      // A file that cannot be watched right now is retried on the next refresh, which also covers it meanwhile.
     }
   }
 }
 
-/** Alternate screen, hidden cursor, mouse reports and raw keys; `quit` restores the terminal. */
-const enterTerminal = (onInput: (input: string) => void, quit: () => void, onResize: () => void) => {
+const STDOUT_FD = 1
+const STDERR_FD = 2
+
+/**
+ * The terminal given back on every end, written synchronously because `exit` waits for nothing: mouse reports and
+ * alternate screen off, cursor shown, raw mode released, once (`onceRestore`).
+ */
+const terminalRestore = (): (() => void) =>
+  onceRestore(TERMINAL_OFF, {
+    write: (text) => writeSync(STDOUT_FD, text),
+    releaseRaw: () => {
+      if (process.stdin.isTTY) process.stdin.setRawMode(false)
+    },
+  })
+
+/** How the view ends: `quit` and `crash` leave, `restore` gives the terminal back and runs on `exit` as well. */
+type TerminalEnds = { quit: () => void; crash: (error: unknown) => void; restore: () => void }
+
+/**
+ * Alternate screen, hidden cursor, mouse reports and raw keys. A signal quits, an error nobody caught crashes (a
+ * closed terminal's `EIO` on stdin among them), and `exit` restores the terminal whatever ended the process.
+ */
+const enterTerminal = (onInput: (input: string) => void, ends: TerminalEnds, onResize: () => void) => {
   process.stdout.write(TERMINAL_ON)
-  process.on('SIGINT', quit)
-  process.on('SIGTERM', quit)
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP'] as const) process.on(signal, ends.quit)
+  process.on('exit', ends.restore)
+  process.on('uncaughtException', ends.crash)
+  process.on('unhandledRejection', ends.crash)
   process.stdout.on('resize', onResize)
   if (!process.stdin.isTTY) return
   process.stdin.setRawMode(true)
+  process.stdin.on('error', ends.crash)
   process.stdin.on('data', (chunk) => {
-    for (const input of splitKeys(chunk.toString())) onInput(input)
+    for (const input of withoutStaleMotions(splitKeys(chunk.toString()))) onInput(input)
   })
 }
 
-const redraw = (live: Live) => {
-  if (!live.snapshot) return
-  const screen = renderSnapshot(
-    live.snapshot,
-    live.view.selection,
-    [...live.errors, ...(live.pageError ? [live.pageError] : []), ...(live.notice ? [live.notice] : [])],
-    paneWidth(),
-    CLOCK_LOCALE,
-  )
-  const top = windowTop(live.view, screen.body.cursorLine, screen.body.lines.length, bodyRows(screen))
+/** The terminal restored first, so the report lands in the shell and not on the alternate screen; null reports nothing. */
+const reportCrash = (report: string | null, restore: () => void) => {
+  restore()
+  if (report === null) return
+  try {
+    writeSync(STDERR_FD, `${report}\n`)
+  } catch {
+    // stderr went away with the terminal; the exit code still tells.
+  }
+}
+
+const hoverScreenOf = (screen: Screen, top: number): HoverScreen => ({
+  header: screen.header,
+  bodyLines: screen.body.lines,
+  focusHits: screen.focusHits,
+  frame: { headerRows: screen.header.length, bodyRows: bodyRows(screen), top },
+})
+
+/** The lines over the footer: refresh errors, a failed page, the notice of the last action. */
+const liveErrors = (live: Live): string[] => [
+  ...live.errors,
+  ...(live.pageError ? [live.pageError] : []),
+  ...(live.notice ? [live.notice] : []),
+]
+
+const shimmerOn = (live: Live): boolean => shimmerEnabled(live.source.settings.shimmer, process.env)
+
+/** 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, live.view.selection, liveErrors(live), paneWidth(), shimmerOn(live))
+  return { screen, top: windowTop(live.view, screen.body.cursorLine, screen.body.lines.length, bodyRows(screen)) }
+}
+
+/**
+ * Draws the current state. When the new layout put another row under a mouse that has the focus and did not move,
+ * that row takes the focus and the screen is rendered once more before it is written. True when it wrote anything.
+ */
+const redraw = (live: Live): boolean => {
+  if (!live.snapshot) return false
+  if (live.frame) clearTimeout(live.frame)
+  live.frame = null
+  let { screen, top } = renderLive(live, live.snapshot)
+  const selection = rehovered(live.view.selection, hoverScreenOf(screen, top), live.mouse)
+  if (selection !== live.view.selection) {
+    live.view = { ...live.view, selection }
+    ;({ screen, top } = renderLive(live, live.snapshot))
+  }
+  live.plain = null
+  return write(live, screen, top)
+}
+
+/**
+ * Writes `screen` scrolled to `top`: the frame built once, only its changed lines, its shimmer rows prepared. True when
+ * a line changed.
+ */
+const write = (live: Live, screen: Screen, top: number): boolean => {
   live.screen = screen
   live.view = { ...live.view, top }
-  const output = frameToWrite(live.written, frameOutput(screen, top, paneWidth(), bodyRows(screen)))
-  if (output === null) return
-  live.written = output
-  process.stdout.write(output)
+  live.lastFrameAt = Date.now()
+  const width = paneWidth()
+  const lines = frameLinesOf(screen, top, bodyRows(screen))
+  followShimmer(live, preparedShimmer(shimmerRows(lines), width))
+  const output = changedLinesOutput(live.written, lines, width, live.lastFrameAt)
+  live.written = lines
+  if (output) process.stdout.write(output)
+  return output !== ''
+}
+
+/**
+ * Keeps the shimmer clock running while a row on the terminal shimmers, and only then: `SHIMMER.framesPerSecond` times a
+ * second it rewrites those rows at their cursor address (`shimmerOutput`), never the rest of the pane; it pauses while a
+ * hover's drawing waits, so the two never write over each other.
+ */
+const followShimmer = (live: Live, prepared: PreparedShimmer) => {
+  live.shimmer.prepared = prepared
+  if (prepared.rows.length === 0 && live.shimmer.clock) {
+    clearInterval(live.shimmer.clock)
+    live.shimmer.clock = null
+  }
+  if (prepared.rows.length > 0 && !live.shimmer.clock) {
+    const draw = () => {
+      if (!live.frame) process.stdout.write(shimmerOutput(live.shimmer.prepared, Date.now()))
+    }
+    live.shimmer.clock = setInterval(draw, 1000 / SHIMMER.framesPerSecond)
+  }
+}
+
+/**
+ * A hover's drawing: the focus laid on the screen without one (`focusedScreen`), no new layout; a row of the blocks on
+ * top, or the help, is drawn whole. The screen without a focus is drawn once, on the first hover after a drawing.
+ */
+const drawHover = (live: Live) => {
+  live.frame = null
+  if (!live.snapshot) return
+  live.plain ??= renderUnfocused(live.snapshot, live.view.selection, liveErrors(live), paneWidth(), shimmerOn(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)
+}
+
+/** A drawing for a hover: at most one per frame time, the ones asked for meanwhile drawn together. */
+const requestFrame = (live: Live) => {
+  if (live.frame) return
+  live.frame = setTimeout(() => drawHover(live), nextFrameDelay(live.lastFrameAt, Date.now()))
 }
 
 /** The whole sprint, also while the view shows one lane: the snapshot is read again without the lane filter. */
@@ -223,12 +366,13 @@ const syncSprintPage = async (live: Live, read: Snapshot) => {
 }
 
 /** A re-read never overlaps another: one asked for meanwhile runs once after the running one, so the screen cannot go back to an older read. */
-const refresh = (live: Live, onChange: () => void): Promise<void> => {
+const refresh = (live: Live, onChange: (file: string) => void): Promise<void> => {
   live.flight ??= singleFlight(() => readOnce(live, onChange))
   return live.flight()
 }
 
-const readOnce = async (live: Live, onChange: () => void) => {
+const readOnce = async (live: Live, onChange: (file: string) => void) => {
+  live.lastRefreshAt = Date.now()
   try {
     const read = await loadSnapshot(live.source, live.pullRequests, live.memories, live.cache)
     rememberLanes(live.source.root, live.memories, read.documents.laneOrder)
@@ -246,13 +390,7 @@ const readOnce = async (live: Live, onChange: () => void) => {
         status: status.agent,
       })),
     )
-    const settled = settledBlockFolds(folded, {
-      waiting: waitingKeys(next.waiting ?? []),
-      next: nextKeys(next.next?.rows ?? []),
-      appointments: appointmentKeys(next.appointments?.rows ?? []),
-      sources: sourceKeys(next.sourceBlock?.sources ?? []),
-    })
-    live.view = { ...live.view, selection: settled }
+    live.view = { ...live.view, selection: folded }
     live.snapshot = next
     const fetchLine = fetchNotice(live.fetch, baseRefOf(live.source.settings), CLOCK_LOCALE)
     live.errors = [
@@ -265,7 +403,7 @@ const readOnce = async (live: Live, onChange: () => void) => {
     const at = clockOf(CLOCK_LOCALE)
     live.errors = [`refresh failed at ${at}, showing the last good state: ${errorText(error)}`]
   }
-  redraw(live)
+  live.quietRounds = quietRoundsAfter(live.quietRounds, redraw(live))
   const { read } = live
   if (read) setTimeout(() => void syncSprintPage(live, read), 0)
 }
@@ -333,8 +471,8 @@ 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
- * cut-off row expands, a file or Artifact opens, a question or a board row asks the coordinator; the failure or the result
- * shows in the footer. An appointment row has nothing to open or ask.
+ * 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 mouse = parseMouse(input)
@@ -342,7 +480,7 @@ const clickBlock = (live: Live, block: TopBlockId, hit: BlockHit | null, input:
   if (blockHeadClick(hit.firstLine - 1, mouse)) {
     live.view = {
       ...live.view,
-      selection: toggledBlockFold(live.view.selection, block, hit.keys),
+      selection: applyClick(live.view.selection, topBlockHeadKey(block)),
     }
     return true
   }
@@ -352,20 +490,16 @@ const clickBlock = (live: Live, block: TopBlockId, hit: BlockHit | null, input:
   return true
 }
 
-/** The mouse moved: the row under it is drawn like the selected one, and the screen is redrawn only when that row changes. */
+/**
+ * The mouse moved: the row under it takes the focus, and the screen is drawn again, at most once per frame time,
+ * only when that row or the button under the mouse changes.
+ */
 const hover = (live: Live, screen: Screen, mouse: MouseEvent): void => {
-  const frame = { headerRows: screen.header.length, bodyRows: bodyRows(screen), top: live.view.top }
-  const key = hoveredKeyAt(screen.focusHits, mouse, frame)
-  const line = lineIndexAt(mouse, frame)
-  const text = line === null ? '' : (screen.header[line] ?? screen.body.lines[line - frame.headerRows] ?? '')
-  const selection = withHovered(
-    live.view.selection,
-    key,
-    key === null ? null : bracketAt(stripAnsi(text), mouse.column - 1),
-  )
+  live.mouse = mouse
+  const selection = hoveredSelection(live.view.selection, hoverScreenOf(screen, live.view.top), mouse)
   if (selection === live.view.selection) return
   live.view = { ...live.view, selection }
-  redraw(live)
+  requestFrame(live)
 }
 
 /**
@@ -382,12 +516,7 @@ const activateBlockRow = (live: Live, screen: Screen, input: string): boolean =>
   return true
 }
 
-const blocksOf = ({ waitingBlock, nextBlock, appointmentBlock, sourceBlock }: Screen): (BlockHit | null)[] => [
-  waitingBlock,
-  nextBlock,
-  appointmentBlock,
-  sourceBlock,
-]
+const blocksOf = ({ yourTurnBlock, sourceBlock }: Screen): (BlockHit | null)[] => [yourTurnBlock, sourceBlock]
 
 const handleInput = (live: Live, input: string) => {
   const { snapshot, screen } = live
@@ -398,7 +527,8 @@ const handleInput = (live: Live, input: string) => {
     return
   }
   live.notice = null
-  live.view = { ...live.view, selection: settledSelection(live.view.selection, screen) }
+  const settled = settledSelection(live.view.selection, screen)
+  live.view = { ...live.view, selection: mouse ? settled : withoutHover(settled) }
   if (activateBlockRow(live, screen, input)) {
     redraw(live)
     return
@@ -408,9 +538,7 @@ const handleInput = (live: Live, input: string) => {
     return
   }
   if (
-    clickBlock(live, TOP_BLOCK.waiting, screen.waitingBlock, input) ||
-    clickBlock(live, TOP_BLOCK.next, screen.nextBlock, input) ||
-    clickBlock(live, TOP_BLOCK.appointments, screen.appointmentBlock, input) ||
+    clickBlock(live, TOP_BLOCK.yourTurn, screen.yourTurnBlock, input) ||
     clickBlock(live, TOP_BLOCK.sources, screen.sourceBlock, input)
   ) {
     redraw(live)
@@ -422,7 +550,6 @@ const handleInput = (live: Live, input: string) => {
     headerRows: screen.header.length,
     bodyRows: bodyRows(screen),
   }
-  live.notice = showDoneNotice(live.view.selection, input, context.keys)
   const pullRequests = snapshot.views.flatMap((view) => view.pullRequests)
   const outcome = inputOutcome(live.view, input, context, (key) => pullRequestUrl(pullRequests, key))
   live.view = outcome.view
@@ -456,12 +583,31 @@ export const runLive = (source: Source): void => {
     page: null,
     pageWriting: false,
     flight: null,
+    quietRounds: 0,
+    lastRefreshAt: null,
     pageError: null,
     written: null,
+    plain: null,
+    mouse: null,
+    lastFrameAt: null,
+    frame: null,
+    shimmer: { prepared: preparedShimmer([], 0), clock: null },
   }
+  /** A refresh asked for outside the pace, bundled by `watchRefreshDelay`: one already pending covers the ask. */
   const schedule = () => {
-    if (live.pending) clearTimeout(live.pending)
-    live.pending = setTimeout(() => refresh(live, schedule), DEBOUNCE_MS)
+    if (live.pending) return
+    live.pending = setTimeout(
+      () => {
+        live.pending = null
+        void refresh(live, onFileChange)
+      },
+      watchRefreshDelay(live.lastRefreshAt, Date.now()),
+    )
+  }
+  /** A watched file changed; `FETCH_HEAD` written by the herd's own fetch asks nothing, its end refreshes once. */
+  const onFileChange = (file: string) => {
+    if (file === live.fetchHead && isOwnFetchWrite(modifiedAt(file), live.fetch)) return
+    schedule()
   }
   const fetchBaseBranch = async () => {
     live.fetch = { ...live.fetch, lastAttempt: Date.now(), running: true }
@@ -476,7 +622,8 @@ export const runLive = (source: Source): void => {
     }
     schedule()
   }
-  const fetchWhenDue = (pullRequestGone: boolean) => {
+  /** Starts a fetch when one is due; true when it did, whose end then refreshes. */
+  const fetchWhenDue = (pullRequestGone: boolean): boolean => {
     const due = shouldFetch({
       now: Date.now(),
       state: live.fetch,
@@ -484,6 +631,7 @@ export const runLive = (source: Source): void => {
       pullRequestGone,
     })
     if (due) void fetchBaseBranch()
+    return due
   }
   const refreshPullRequests = async () => {
     const previous = live.pullRequests
@@ -491,32 +639,38 @@ export const runLive = (source: Source): void => {
     const readable = previous.errors.length === 0 && live.pullRequests.errors.length === 0
     const laneBranches = new Set(live.snapshot?.views.flatMap(({ status }) => (status.branch ? [status.branch] : [])))
     const gone = goneLanePullRequests(previous.byBranch, live.pullRequests.byBranch, laneBranches)
-    fetchWhenDue(readable && gone.length > 0)
-    schedule()
+    if (!fetchWhenDue(readable && gone.length > 0)) schedule()
   }
+  const restore = terminalRestore()
   const leave = (code: number) => {
+    restore()
     clearTitles(source, live.reported)
     source.terminal.labelOwnPane(null)
     for (const watcher of live.watchers.values()) watcher.close()
-    process.stdout.write(TERMINAL_OFF)
     process.exit(code)
   }
   const quit = () => leave(0)
+  const crash = (error: unknown) => {
+    const { code, report } = crashEnd(error)
+    reportCrash(report, restore)
+    leave(code)
+  }
   const takenOver = () => leave(TAKEN_OVER_CODE)
   const onInput = (input: string) => (QUIT_KEYS.has(input) ? quit() : handleInput(live, input))
 
   source.terminal.labelOwnPane(herdLabel(source.options.lane))
   process.removeAllListeners(TAKEOVER_SIGNAL)
   process.on(TAKEOVER_SIGNAL, takenOver)
-  enterTerminal(onInput, quit, () => {
+  enterTerminal(onInput, { quit, crash, restore }, () => {
     live.written = null
     redraw(live)
   })
-  setInterval(() => {
+  const poll = () => {
     fetchWhenDue(false)
-    void refresh(live, schedule)
-  }, REFRESH_MS)
+    void refresh(live, onFileChange).finally(() => setTimeout(poll, refreshDelay(live.quietRounds)))
+  }
+  setTimeout(poll, REFRESH_PACE.baseMs)
   setInterval(refreshPullRequests, PULL_REQUEST_REFRESH_MS)
-  void refresh(live, schedule)
+  void refresh(live, onFileChange)
   void refreshPullRequests()
 }