jackherd 1.12.1 → 1.12.3

package/src/plans/live.ts

@@ -1,34 +1,36 @@
-import { existsSync, type FSWatcher, statSync, watch, writeSync } from 'node:fs'
+import { existsSync, type FSWatcher, watch } 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 { enterTerminal, reportCrash, terminalRestore } from '../terminal/lifetime'
 import { openInBrowser } from '../terminal/open'
-import { crashEnd, onceRestore } from '../terminal/restore'
+import { crashEnd } from '../terminal/restore'
 import { closeWaiting } from '../waiting/command'
+import { isWatcherRunning } from '../watch/watcher-lock'
 import { askCoordinator } from './ask-coordinator'
-import type { LaneMemory } from './current-phase'
 import { errorText } from './error-text'
+import { focusedScreen } from './focus-overlay'
+import { noPullRequests } from './github'
 import {
-  type FetchState,
-  fetchBase,
-  fetchNotice,
-  fetchPlanHeads,
-  goneLanePullRequests,
-  initialFetchState,
-  shouldFetch,
-  watchedFiles,
-} from './fetch'
-import { fetchHeadPath } from './git'
-import { fetchPullRequests, noPullRequests, type PullRequestState } from './github'
-import { recallLanes, rememberLanes } from './herd-memory'
+  HERD_FILES,
+  type HerdPlans,
+  type HerdRead,
+  herdFilesOf,
+  isPublishedLive,
+  laneRead,
+  publishedRead,
+  readHerdBeat,
+  readHerdPlans,
+  readHerdRead,
+} from './herd-state'
 import { type Screen, settledSelection } from './layout'
-import { type KnownPage, pageAfterWrite, pageKey, pageNeedsWriting, planAnchorOn, withPlanChips } from './plan-chips'
-import { planPullRequests } from './plan-heads'
+import { initialPageState, type PageState, syncSprintPage } from './page-sync'
+import { pageKey, pageNeedsWriting, planAnchorOn, withPlanChips } from './plan-chips'
 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 { type Reader, type ReadOutcome, startReader } from './reader'
+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'
@@ -51,64 +53,56 @@ import {
   windowTop,
   withoutStaleMotions,
 } from './selection'
-import { BASE_REMOTE, baseRefOf, boardRepoPathOf, CLOCK_LOCALE } from './settings'
+import { 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 { exportSprintPage, writeSprintPageInSteps } from './sprint-export'
+import { exportSprintPage } from './sprint-export'
 import { boardTexts } from './texts'
 import {
   agentOfSnapshot,
   bodyRows,
   changedLinesOutput,
   clockOf,
-  focusedScreen,
   frameLinesOf,
   nextFrameDelay,
   type PreparedShimmer,
   paneWidth,
   preparedShimmer,
+  type RenderContext,
   renderSnapshot,
   renderUnfocused,
   shimmerOutput,
   startSelection,
-  TERMINAL_OFF,
-  TERMINAL_ON,
 } from './view'
 import { type BlockClick, type BlockHit, blockClick, blockHeadClick, mainClickOf } from './waiting-click'
-import { isOwnFetchWrite, watchRefreshDelay } from './watch-burst'
+
+/**
+ * Where the herd's reads come from: its own reader, or the read the watcher publishes for every herd of the board
+ * (`herd-state.ts`), with the watcher on the directory it writes to and what was taken from it last.
+ */
+type Feed =
+  | { kind: 'own'; reader: Reader }
+  | { kind: 'published'; directory: FSWatcher | null; taken: { read: HerdRead; plans: HerdPlans } | null }
 
 /** The state of the running view; only the functions below `runLive` change it. */
 type Live = {
   source: Source
+  /** What the herd shares with the watcher to take its read (`publishedKey`); null when it never does. */
+  key: string | null
+  feed: Feed | null
   snapshot: Snapshot | null
   screen: Screen | null
   view: View
   errors: string[]
-  pullRequests: PullRequestState
-  fetch: FetchState
   /** 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
-  watchers: Map<string, FSWatcher>
-  /** This clone's `FETCH_HEAD`, watched beside the plan files; null when git names none. */
-  fetchHead: string | null
   reported: Map<string, string | null>
-  /** Per lane, the ticks seen at the last read, the phase that moved last and when each moved; kept across herds (`rememberLanes`). */
-  memories: Map<string, LaneMemory>
-  /** Session logs and plans parsed at the last read, kept while they did not change. */
-  cache: ReadCache
-  pending: Timer | null
-  /** The snapshot as read, without the plan chips; `snapshot` is this plus the chips of `page`. */
+  /** The snapshot as read, without the plan chips; `snapshot` is this plus the chips of the page. */
   read: Snapshot | null
+  /** The whole board as the watcher published it, while the herd shows one lane of it; null otherwise. */
+  whole: Snapshot | null
   /** The sprint page last written, and the key of the plans it was built from; a click on a plan chip opens it. */
-  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
+  pageState: PageState
   /**
    * 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.
@@ -126,18 +120,8 @@ type Live = {
   shimmer: { prepared: PreparedShimmer; clock: Timer | null }
 }
 
-const PULL_REQUEST_REFRESH_MS = 60_000
 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>,
@@ -161,76 +145,6 @@ const clearTitles = (source: Source, reported: Map<string, string | null>) => {
   }
 }
 
-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()
-    watchers.delete(file)
-  }
-  for (const file of files.filter((candidate) => !watchers.has(candidate))) {
-    try {
-      const watcher = watch(file, (event) => {
-        if (event === 'rename') {
-          watcher.close()
-          watchers.delete(file)
-        }
-        onChange(file)
-      })
-      watchers.set(file, watcher)
-    } catch {
-      // A file that cannot be watched right now is retried on the next refresh, which also covers it meanwhile.
-    }
-  }
-}
-
-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)
-  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 withoutStaleMotions(splitKeys(chunk.toString()))) onInput(input)
-  })
-}
-
-/** 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,
@@ -241,15 +155,22 @@ const hoverScreenOf = (screen: Screen, top: number): HoverScreen => ({
 /** 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.pageState.error ? [live.pageState.error] : []),
   ...(live.notice ? [live.notice] : []),
 ]
 
 const shimmerOn = (live: Live): boolean => shimmerEnabled(live.source.settings.shimmer, process.env)
 
+const renderContextOf = (live: Live): RenderContext => ({
+  selection: live.view.selection,
+  errors: liveErrors(live),
+  width: paneWidth(),
+  shimmer: shimmerOn(live),
+})
+
 /** 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))
+  const screen = renderSnapshot(snapshot, renderContextOf(live))
   return { screen, top: windowTop(live.view, screen.body.cursorLine, screen.body.lines.length, bodyRows(screen)) }
 }
 
@@ -314,7 +235,7 @@ const followShimmer = (live: Live, prepared: PreparedShimmer) => {
 const drawHover = (live: Live) => {
   live.frame = null
   if (!live.snapshot) return
-  live.plain ??= renderUnfocused(live.snapshot, live.view.selection, liveErrors(live), paneWidth(), shimmerOn(live))
+  live.plain ??= renderUnfocused(live.snapshot, 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)
@@ -326,11 +247,16 @@ const requestFrame = (live: Live) => {
   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. */
-const wholeSprint = async (live: Live, snapshot: Snapshot): Promise<Snapshot> =>
-  live.source.options.lane
-    ? loadSnapshot({ ...live.source, options: { ...live.source.options, lane: null } }, live.pullRequests)
-    : snapshot
+/**
+ * The whole sprint, also while the view shows one lane: the watcher's read holds it, the herd's own reader reads the
+ * snapshot again without the lane filter.
+ */
+const wholeSprint = async (live: Live, snapshot: Snapshot): Promise<Snapshot> => {
+  if (!live.source.options.lane) return snapshot
+  if (live.whole) return live.whole
+  const pullRequests = live.feed?.kind === 'own' ? live.feed.reader.pullRequests() : noPullRequests()
+  return loadSnapshot({ ...live.source, options: { ...live.source.options, lane: null } }, pullRequests)
+}
 
 const boardTextsOf = (live: Live) => boardTexts(live.source.settings.board.term)
 
@@ -338,74 +264,150 @@ const sprintDirectoryOf = ({ root, sprintFile, settings }: Source): string =>
   dirname(boardRepoPathOf(root, settings, sprintFile))
 
 /** The snapshot as read with the plan chips of the page written so far, none before the first one. */
-const withKnownPage = (live: Live, read: Snapshot): Snapshot =>
-  live.page ? withPlanChips(read, live.page, sprintDirectoryOf(live.source)) : read
+const withKnownPage = (live: Live, read: Snapshot): Snapshot => {
+  const { page } = live.pageState
+  return page ? withPlanChips(read, page, sprintDirectoryOf(live.source)) : read
+}
+
+const isCurrent = (live: Live, read: Snapshot): boolean => {
+  const { page } = live.pageState
+  return page !== null && !pageNeedsWriting(page, pageKey(read), existsSync(page.path))
+}
 
-const isCurrent = (live: Live, read: Snapshot): boolean =>
-  live.page !== null && !pageNeedsWriting(live.page, pageKey(read), existsSync(live.page.path))
+/** Writes the sprint page from the herd's own read when its plans changed (`syncSprintPage`), then draws its chips. */
+const syncPage = async (live: Live, read: Snapshot, feed: Feed) => {
+  if (live.feed !== feed) return
+  if (!(await syncSprintPage(live.pageState, live.source, read, () => wholeSprint(live, read)))) return
+  if (live.feed !== feed) return
+  if (live.read) live.snapshot = withKnownPage(live, live.read)
+  redraw(live)
+}
 
 /**
- * Writes the sprint page, so a plan chip's link points at a file that exists. Only when the plans it is built
- * from changed or the file is gone: building it takes seconds, with the event loop blocked for all of them.
+ * Takes a read into the view, from the herd's own reader or from the watcher: the selection follows the lanes, the
+ * errors (`notes` after the read's own) and the pane titles are set, and the screen is drawn. True when it wrote
+ * anything.
  */
-const syncSprintPage = async (live: Live, read: Snapshot) => {
-  const key = pageKey(read)
-  if (live.pageWriting || !pageNeedsWriting(live.page, key, live.page !== null && existsSync(live.page.path))) return
-  live.pageWriting = true
-  try {
-    const written = await writeSprintPageInSteps(live.source, await wholeSprint(live, read))
-    live.pageError = 'error' in written ? boardTextsOf(live).pageNotWritten(written.error) : null
-    live.page = pageAfterWrite(live.page, written, key)
-  } catch (error) {
-    live.pageError = boardTextsOf(live).pageNotWritten(errorText(error))
-  } finally {
-    live.pageWriting = false
+const takeRead = (live: Live, outcome: ReadOutcome, notes: readonly string[]): boolean => {
+  if ('error' in outcome) {
+    const at = clockOf(CLOCK_LOCALE)
+    live.errors = [`refresh failed at ${at}, showing the last good state: ${outcome.error}`]
+    return redraw(live)
   }
-  if (live.read) live.snapshot = withKnownPage(live, live.read)
-  redraw(live)
+  const next = withKnownPage(live, outcome.read)
+  live.read = outcome.read
+  if (!live.snapshot)
+    live.view = {
+      ...live.view,
+      selection: startSelection(next, live.source.options),
+    }
+  const folded = syncLaneFolds(
+    live.view.selection,
+    next.views.map(({ progress, status }) => ({
+      lane: progress.lane.name,
+      status: status.agent,
+    })),
+  )
+  live.view = { ...live.view, selection: folded }
+  live.snapshot = next
+  live.errors = [...next.errors, ...notes, ...reportTitles(live.source, next.titles, live.reported)]
+  return redraw(live)
 }
 
-/** 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: (file: string) => void): Promise<void> => {
-  live.flight ??= singleFlight(() => readOnce(live, onChange))
-  return live.flight()
+/** The herd's own reader: it takes each read and writes the sprint page from it. */
+const ownFeed = (live: Live): Feed => {
+  const reader = startReader(live.source, (outcome) => {
+    const fetchLine = reader.fetchLine()
+    const changed = takeRead(live, outcome, fetchLine ? [fetchLine] : [])
+    const { read } = live
+    if (read) setTimeout(() => void syncPage(live, read, feed), 0)
+    return changed
+  })
+  const feed: Feed = { kind: 'own', reader }
+  return feed
+}
+
+/** Shows what was taken from the watcher, at the herd's own time: the whole board, or the herd's lane of it. */
+const showPublished = (live: Live, taken: { read: HerdRead; plans: HerdPlans }): boolean => {
+  const published = publishedRead(taken.read, taken.plans.plans, Date.now())
+  const { lane } = live.source.options
+  live.whole = lane ? published.snapshot : null
+  live.pageState.page = published.page
+  const shown = lane ? laneRead(published.snapshot, lane, boardTextsOf(live).laneNotListed) : published.snapshot
+  return takeRead(live, { read: shown }, published.fetchLine ? [published.fetchLine] : [])
 }
 
-const readOnce = async (live: Live, onChange: (file: string) => void) => {
-  live.lastRefreshAt = Date.now()
+/**
+ * Takes the watcher's read when it is for this herd's key; the plan texts are read again only when their key moved.
+ * A read the watcher is still writing is never seen half: it replaces the file whole.
+ */
+const takePublished = (live: Live, feed: Extract<Feed, { kind: 'published' }>): void => {
+  const files = herdFilesOf(live.source.root)
+  const read = readHerdRead(files.read)
+  const kept = feed.taken?.plans
+  const plans = read && (kept?.plansKey === read.plansKey ? kept : readHerdPlans(files.plans))
+  if (!read || read.key !== live.key || !plans || plans.plansKey !== read.plansKey) {
+    if (feed.taken) showPublished(live, feed.taken)
+    return
+  }
+  feed.taken = { read, plans }
+  showPublished(live, feed.taken)
+}
+
+/** Follows the watcher's read: woken by its file, without a timer of its own. */
+const publishedFeed = (live: Live): Feed => {
+  const feed: Extract<Feed, { kind: 'published' }> = { kind: 'published', directory: null, taken: null }
+  const files = herdFilesOf(live.source.root)
+  let pending = false
+  const onChange = (_event: string, name: string | null) => {
+    if (name !== HERD_FILES.read || pending) return
+    pending = true
+    setTimeout(() => {
+      pending = false
+      if (live.feed === feed) takePublished(live, feed)
+    }, 0)
+  }
   try {
-    const read = await loadSnapshot(live.source, live.pullRequests, live.memories, live.cache)
-    rememberLanes(live.source.root, live.memories, read.documents.laneOrder)
-    const next = withKnownPage(live, read)
-    live.read = read
-    if (!live.snapshot)
-      live.view = {
-        ...live.view,
-        selection: startSelection(next, live.source.options),
-      }
-    const folded = syncLaneFolds(
-      live.view.selection,
-      next.views.map(({ progress, status }) => ({
-        lane: progress.lane.name,
-        status: status.agent,
-      })),
-    )
-    live.view = { ...live.view, selection: folded }
-    live.snapshot = next
-    const fetchLine = fetchNotice(live.fetch, baseRefOf(live.source.settings), CLOCK_LOCALE)
-    live.errors = [
-      ...next.errors,
-      ...(fetchLine ? [fetchLine] : []),
-      ...reportTitles(live.source, next.titles, live.reported),
-    ]
-    syncWatchers(live.watchers, watchedFiles(next.files, live.fetchHead), onChange)
-  } catch (error) {
-    const at = clockOf(CLOCK_LOCALE)
-    live.errors = [`refresh failed at ${at}, showing the last good state: ${errorText(error)}`]
+    feed.directory = watch(dirname(files.read), onChange)
+  } catch {
+    feed.directory = null
   }
-  live.quietRounds = quietRoundsAfter(live.quietRounds, redraw(live))
-  const { read } = live
-  if (read) setTimeout(() => void syncSprintPage(live, read), 0)
+  takePublished(live, feed)
+  return feed
+}
+
+/** Whether the watcher publishes a young read for this herd's key (`isPublishedLive`). */
+const isPublishedForHerd = (live: Live): boolean => {
+  const files = herdFilesOf(live.source.root)
+  return isPublishedLive({
+    beat: readHerdBeat(files.beat),
+    key: live.key,
+    watcherRunning: isWatcherRunning(files.lock),
+    now: Date.now(),
+  })
+}
+
+const stopFeed = (feed: Feed | null): void => {
+  if (feed?.kind === 'own') feed.reader.stop()
+  else feed?.directory?.close()
+}
+
+/**
+ * Switches to the watcher's read while it publishes one for this herd, and back to reading itself once it stops or
+ * grows old; while it follows the watcher, the sources' ages are drawn again at the herd's time.
+ */
+const followFeed = (live: Live): void => {
+  const published = isPublishedForHerd(live)
+  const { feed } = live
+  if (feed?.kind === 'published' && published) {
+    takePublished(live, feed)
+    return
+  }
+  if (feed?.kind === 'own' && !published) return
+  stopFeed(feed)
+  live.whole = null
+  live.pageState.error = null
+  live.feed = published ? publishedFeed(live) : ownFeed(live)
 }
 
 const writeSprintPage = async (live: Live, snapshot: Snapshot, anchor: string | null = null) => {
@@ -423,15 +425,17 @@ const writeSprintPage = async (live: Live, snapshot: Snapshot, anchor: string |
  * first. Any other `file:` address is refused.
  */
 const openPlan = (live: Live, snapshot: Snapshot, address: string) => {
-  const anchor = planAnchorOn(live.page?.path ?? null, address)
-  if (!anchor || !live.page) return
-  if (!live.read || !isCurrent(live, live.read)) {
+  const { page } = live.pageState
+  const anchor = planAnchorOn(page?.path ?? null, address)
+  if (!anchor || !page) return
+  const read = live.whole ?? live.read
+  if (!read || !isCurrent(live, read)) {
     void writeSprintPage(live, snapshot, anchor)
     return
   }
-  const reason = openInBrowser(`${pathToFileURL(live.page.path).href}#${anchor}`)
+  const reason = openInBrowser(`${pathToFileURL(page.path).href}#${anchor}`)
   const texts = boardTextsOf(live)
-  live.notice = reason === null ? texts.pageOpened(live.page.path) : texts.pageNotOpenedReason(reason)
+  live.notice = reason === null ? texts.pageOpened(page.path) : texts.pageNotOpenedReason(reason)
 }
 
 /**
@@ -563,29 +567,24 @@ const handleInput = (live: Live, input: string) => {
   redraw(live)
 }
 
-export const runLive = (source: Source): void => {
+/**
+ * Runs the live view of `source`. With a `key` (`publishedKey`) it takes the read the watcher publishes for it while
+ * there is one, and reads for itself otherwise; without one it always reads for itself.
+ */
+export const runLive = (source: Source, key: string | null = null): void => {
   const live: Live = {
     source,
+    key,
+    feed: null,
     snapshot: null,
     screen: null,
     view: { selection: overviewSelection(), top: 0, follow: true },
     errors: [],
-    pullRequests: noPullRequests(),
-    fetch: initialFetchState(),
     notice: null,
-    watchers: new Map(),
-    fetchHead: fetchHeadPath(source.root),
     reported: new Map(),
-    memories: recallLanes(source.root),
-    cache: newReadCache(),
-    pending: null,
     read: null,
-    page: null,
-    pageWriting: false,
-    flight: null,
-    quietRounds: 0,
-    lastRefreshAt: null,
-    pageError: null,
+    whole: null,
+    pageState: initialPageState(),
     written: null,
     plain: null,
     mouse: null,
@@ -593,60 +592,12 @@ export const runLive = (source: Source): void => {
     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) 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 }
-    const failure = await fetchBase(source.root, BASE_REMOTE, source.settings.baseBranch)
-    const planHeads = planPullRequests([...live.pullRequests.byBranch.values()].flat(), source.settings.planDirectory)
-    if (failure === null) await fetchPlanHeads(source.root, BASE_REMOTE, planHeads)
-    live.fetch = {
-      ...live.fetch,
-      running: false,
-      failure,
-      lastSuccess: failure === null ? new Date() : live.fetch.lastSuccess,
-    }
-    schedule()
-  }
-  /** 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,
-      intervalMinutes: source.settings.fetchIntervalMinutes,
-      pullRequestGone,
-    })
-    if (due) void fetchBaseBranch()
-    return due
-  }
-  const refreshPullRequests = async () => {
-    const previous = live.pullRequests
-    live.pullRequests = await fetchPullRequests(source.root)
-    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)
-    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()
+    stopFeed(live.feed)
     process.exit(code)
   }
   const quit = () => leave(0)
@@ -661,16 +612,13 @@ export const runLive = (source: Source): void => {
   source.terminal.labelOwnPane(herdLabel(source.options.lane))
   process.removeAllListeners(TAKEOVER_SIGNAL)
   process.on(TAKEOVER_SIGNAL, takenOver)
-  enterTerminal(onInput, { quit, crash, restore }, () => {
+  const onData = (chunk: string) => {
+    for (const input of withoutStaleMotions(splitKeys(chunk))) onInput(input)
+  }
+  enterTerminal(onData, { quit, crash, restore }, () => {
     live.written = null
     redraw(live)
   })
-  const poll = () => {
-    fetchWhenDue(false)
-    void refresh(live, onFileChange).finally(() => setTimeout(poll, refreshDelay(live.quietRounds)))
-  }
-  setTimeout(poll, REFRESH_PACE.baseMs)
-  setInterval(refreshPullRequests, PULL_REQUEST_REFRESH_MS)
-  void refresh(live, onFileChange)
-  void refreshPullRequests()
+  followFeed(live)
+  setInterval(() => followFeed(live), REFRESH_PACE.maxMs)
 }

package/src/plans/markdown-text.ts

@@ -0,0 +1,4 @@
+const MARKDOWN_MARKS = /\*\*|`/g
+
+/** The text without its bold and code marks, as every row but a heading draws it. */
+export const plain = (text: string): string => text.replace(MARKDOWN_MARKS, '')