jackherd 1.12.1 → 1.12.3

package/src/plans/focus-overlay.ts

@@ -0,0 +1,80 @@
+import { fit, paint } from '../terminal/text'
+import { type AgentOf, clickHint } from './click-hint'
+import type { Screen } from './layout'
+import { blockRowByKey, boldBracketAt, type FocusHit, focusLine, isFocused, LINKS_KEY_PREFIX } from './row-focus'
+import type { Selection } from './selection'
+import { TEXTS } from './texts'
+
+const NO_ROW = '\0'
+const LEAD = /^ */
+
+/** A selection that focuses no row: the screen drawn with it is the base `focusedScreen` lays the focus on. */
+export const unfocused = (selection: Selection): Selection => ({
+  ...selection,
+  selected: NO_ROW,
+  hovered: null,
+  hoveredFrom: null,
+})
+
+/** The blanks a block puts before a row it holds (`indented`): the focus lies right of them, as narrow as the row. */
+const leadOf = (line: string): number => LEAD.exec(line)?.[0].length ?? 0
+
+/** `lines` with the lines of `hit` (counted from `offset`) changed by `change`, the first line told by its index. */
+const changedHit = (
+  lines: readonly string[],
+  offset: number,
+  hit: FocusHit | undefined,
+  change: (line: string, index: number) => string,
+): string[] =>
+  lines.map((line, at) => {
+    const index = hit ? at + offset - hit.line : -1
+    return hit && index >= 0 && index < hit.lines ? change(line, index) : line
+  })
+
+/**
+ * `screen` with the focus `state` gives laid on one region of `lines`: the focused row on the focus background and
+ * mark, a line of links under the mouse marked alone, and the square-bracket button under the mouse bold.
+ */
+const focusedLines = (lines: readonly string[], offset: number, screen: Screen, state: Selection, width: number) => {
+  const hitOf = (key: string | null | undefined) => (key ? screen.focusHits.find((hit) => hit.key === key) : undefined)
+  const hovered = hitOf(state.hovered)
+  const focusedKey = state.selected !== null && isFocused(state, state.selected) ? state.selected : null
+  const focusedHit = hitOf(focusedKey)
+  const gutter = focusedHit ? leadOf(lines[focusedHit.line - offset] ?? '') : 0
+  const focused = changedHit(
+    lines,
+    offset,
+    focusedHit,
+    (line, index) => `${line.slice(0, gutter)}${focusLine(line.slice(gutter), width - gutter, index === 0)}`,
+  )
+  const links = state.hovered?.startsWith(LINKS_KEY_PREFIX)
+    ? changedHit(focused, offset, hovered, (line, index) => (index === 0 ? focusLine(line, width, true) : line))
+    : focused
+  const from = state.hoveredFrom
+  return from == null
+    ? links
+    : changedHit(links, offset, hovered, (line, index) => (index === 0 ? boldBracketAt(line, from) : line))
+}
+
+/**
+ * The screen a full drawing with `state` gives, laid on `plain` (drawn with `unfocused`) without a new layout: a hover
+ * only moves the focus. Null where it needs the layout: with the help open, or for a row of the blocks on top, whose
+ * buttons stand only at the selection. `agentOf` says a lane's agent, for the footer's click hint.
+ */
+export const focusedScreen = (plain: Screen, state: Selection, width: number, agentOf: AgentOf): Screen | null => {
+  const blocks = [plain.yourTurnBlock, plain.sourceBlock]
+  const isBlockRow = (key: string | null | undefined) => !!key && blockRowByKey(blocks, key) !== null
+  if (state.showLegend || isBlockRow(state.selected) || isBlockRow(state.hovered)) return null
+  const header = focusedLines(plain.header, 0, plain, state, width)
+  const lines = focusedLines(plain.body.lines, plain.header.length, plain, state, width)
+  const selectedHit = plain.focusHits.find(({ key }) => key === state.selected)
+  const cursorLine =
+    selectedHit && selectedHit.line >= plain.header.length ? selectedHit.line - plain.header.length : -1
+  const hint = clickHint(state, (key) => blockRowByKey(blocks, key), agentOf) ?? TEXTS.hint
+  return {
+    ...plain,
+    header,
+    body: { ...plain.body, lines, cursorLine },
+    footer: [...plain.footer.slice(0, -1), fit(paint.dim(hint), width)],
+  }
+}

package/src/plans/git.ts

@@ -1,9 +1,8 @@
 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'
+import type { BranchStatus, WorktreeStatus } from './status-pace'
 
 /** 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
@@ -176,33 +175,29 @@ export const branchStatusOf = (output: string | null): BranchStatus => {
   }
 }
 
-/** 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) =>
+const branchStatusAt = async (worktree: string, pass: () => Promise<void>): Promise<BranchStatus> =>
   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`).
+ * each starts after `pass` (a `SliceGate`), so the starts of many worktrees' calls do not add up to one block. The
+ * herd keeps the answer while nothing moved (`pacedStatus`).
  */
 export const gitStatusOf = async (
   worktree: string,
   baseRef: string,
   pass: () => Promise<void> = passAtOnce,
-  readBranchStatus: BranchStatusReader = branchStatusAt,
-): Promise<Pick<LaneStatus, 'branch' | 'ahead' | 'dirty'>> => {
+): Promise<WorktreeStatus> => {
   if (!existsSync(worktree)) return { branch: null, ahead: null, dirty: 0 }
   const [count, status] = await Promise.all([
     gitAsync(worktree, ['rev-list', '--count', `${baseRef}..HEAD`], pass),
-    readBranchStatus(worktree, pass),
+    branchStatusAt(worktree, pass),
   ])
   const ahead = Number.parseInt(count ?? '', 10)
   return { ...status, ahead: Number.isNaN(ahead) ? null : ahead }

package/src/plans/herd-state.ts

@@ -0,0 +1,201 @@
+import { join } from 'node:path'
+import { writePrivateFile } from '../../kit/hooks/hooks/shared/private-directory'
+import { readPrivateText } from '../shared/private-location'
+import type { StartedKit } from '../version/started-kit'
+import { WATCHER_FILES, watcherDirectoryOf } from '../watch/watcher-lock'
+import type { KnownPage } from './plan-chips'
+import { REFRESH_PACE } from './refresh-pace'
+import type { PlansSettings } from './settings'
+import type { Snapshot, SnapshotDocuments } from './snapshot'
+
+/** A read the watcher published, as the herd takes it: the snapshot, the sprint page written from it, the fetch line. */
+export type PublishedRead = { snapshot: Snapshot; page: KnownPage | null; fetchLine: string | null }
+
+/** The snapshot as the file holds it: the pane titles as pairs, the plan texts in a file of their own (`HerdPlans`). */
+type StoredSnapshot = Omit<Snapshot, 'titles' | 'documents'> & {
+  titles: [string, string | null][]
+  documents: Omit<SnapshotDocuments, 'plans'>
+}
+
+type StoredPage = Omit<KnownPage, 'anchors'> & { anchors: [string, string][] }
+
+/** `herd-read.json`: the published read, for the herds of the board, settings and kit `key` names. */
+export type HerdRead = {
+  key: string
+  at: number
+  plansKey: string
+  snapshot: StoredSnapshot
+  page: StoredPage | null
+  fetchLine: string | null
+}
+
+/** `herd-plans.json`: the plan texts of the read, written only when they changed. */
+export type HerdPlans = { plansKey: string; plans: Record<string, string> }
+
+/**
+ * `herd-beat.json`: when the watcher last read with success, for which `key`; a herd trusts the read only while this
+ * is young and names its own key, so a watcher whose reads fail lets the herds read for themselves and show why.
+ */
+export type HerdBeat = { key: string; at: number }
+
+/** What the herd checks before it takes the watcher's read: the beat, its own key, and whether the watcher still runs. */
+export type Liveness = { beat: HerdBeat | null; key: string | null; watcherRunning: boolean; now: number }
+
+export const HERD_FILES = { read: 'herd-read.json', plans: 'herd-plans.json', beat: 'herd-beat.json' } as const
+
+/**
+ * How old the watcher's last read may be before a herd reads for itself again: three of the slowest refreshes, so one
+ * slow read or a busy watcher does not flip the herd back and forth.
+ */
+export const PUBLISHED_MAX_AGE_MS = 3 * REFRESH_PACE.maxMs
+
+/** Raised when the file layout changes, so a herd never takes a read of another layout. */
+const FORMAT = 1
+
+const hashOf = (value: unknown): string => Bun.hash(JSON.stringify(value)).toString(36)
+
+/**
+ * What a herd and the watcher must share for the herd to take the watcher's read: the checkout, the board, the
+ * settings and the kit that read it (its version and where it lies, so a herd running other code reads for itself).
+ */
+export const publishedKey = (
+  context: { root: string; sprintFile: string; settings: PlansSettings },
+  kit: StartedKit,
+): string => hashOf([FORMAT, kit.version, kit.packageRoot, context.root, context.sprintFile, context.settings])
+
+/** The plan texts' key, so a herd reads `herd-plans.json` again only when they changed. */
+export const plansKeyOf = (plans: Record<string, string>): string =>
+  hashOf(Object.entries(plans).map(([href, text]) => [href, Bun.hash(text).toString(36)]))
+
+/** The read as the file holds it. */
+export const storedRead = (read: PublishedRead, key: string, at: number): HerdRead => {
+  const { titles, documents, ...rest } = read.snapshot
+  const { plans, ...otherDocuments } = documents
+  return {
+    key,
+    at,
+    plansKey: plansKeyOf(plans),
+    snapshot: { ...rest, titles: [...titles], documents: otherDocuments },
+    page: read.page && { ...read.page, anchors: [...read.page.anchors] },
+    fetchLine: read.fetchLine,
+  }
+}
+
+/**
+ * The snapshot with its clocks set to `now`: the sources' ages and your turn's, which the reader draws at its own
+ * time with every read.
+ */
+const clockedAt = <T extends Pick<Snapshot, 'sourceBlock' | 'yourTurn'>>(snapshot: T, now: number): T => {
+  const { sourceBlock, yourTurn, ...rest } = snapshot
+  return {
+    ...rest,
+    ...(sourceBlock ? { sourceBlock: { ...sourceBlock, now } } : {}),
+    ...(yourTurn ? { yourTurn: { ...yourTurn, now } } : {}),
+  } as T
+}
+
+/** The read from the files, the plan texts from `plans`; `now` is the time the herd draws the ages at. */
+export const publishedRead = (stored: HerdRead, plans: Record<string, string>, now: number): PublishedRead => {
+  const { titles, documents, ...rest } = clockedAt(stored.snapshot, now)
+  return {
+    snapshot: {
+      ...rest,
+      titles: new Map(titles),
+      documents: { ...documents, plans },
+    },
+    page: stored.page && { ...stored.page, anchors: new Map(stored.page.anchors) },
+    fetchLine: stored.fetchLine,
+  }
+}
+
+/**
+ * What decides whether the read changed: everything but its time and the clocks of the sources and your turn, which
+ * move with every read while the herd draws the ages at its own time.
+ */
+export const readContent = ({ at: _at, snapshot, ...rest }: HerdRead): string =>
+  JSON.stringify({ ...rest, snapshot: clockedAt(snapshot, 0) })
+
+/** What the publisher wrote last: the read's content (`readContent`) and the plan texts' key; null before the first. */
+export type Written = { content: string | null; plansKey: string | null }
+
+/**
+ * Which files a new read rewrites: the plan texts only when their key moved, the read only when its content did. The
+ * beat is written after every read that worked, whatever this says. `content` is the read's `readContent`, kept for
+ * the next comparison, so the board is serialized once per read.
+ */
+export const publishDecision = (
+  written: Written,
+  stored: HerdRead,
+): { writePlans: boolean; writeRead: boolean; content: string } => {
+  const content = readContent(stored)
+  return { writePlans: stored.plansKey !== written.plansKey, writeRead: content !== written.content, content }
+}
+
+/**
+ * The whole board's read as the herd of one lane would have read it: that lane's view and pane title only, nothing
+ * planned or unplaced, and the board's notice when the lane is not on it.
+ */
+export const laneRead = (snapshot: Snapshot, lane: string, laneNotListed: (lane: string) => string): Snapshot => {
+  const views = snapshot.views.filter((view) => view.progress.lane.name === lane)
+  const pane = snapshot.panes?.[lane]
+  return {
+    ...snapshot,
+    title: views.length === 0 ? laneNotListed(lane) : snapshot.title,
+    views,
+    documents: { ...snapshot.documents, laneOrder: snapshot.documents.laneOrder.filter((name) => name === lane) },
+    planned: [],
+    titles: new Map([...snapshot.titles].filter(([titled]) => titled === pane)),
+    panes: pane ? { [lane]: pane } : {},
+    unplaced: [],
+  }
+}
+
+/**
+ * Whether a herd may take the watcher's read: the watcher runs, read for the herd's key within
+ * `PUBLISHED_MAX_AGE_MS`. A herd without a key (its kit is no release) never does.
+ */
+export const isPublishedLive = ({ beat, key, watcherRunning, now }: Liveness): boolean =>
+  watcherRunning && key !== null && beat !== null && beat.key === key && now - beat.at <= PUBLISHED_MAX_AGE_MS
+
+const parsed = <T>(text: string | null, isShape: (value: Record<string, unknown>) => boolean): T | null => {
+  if (text === null) return null
+  try {
+    const value: unknown = JSON.parse(text)
+    return value && typeof value === 'object' && isShape(value as Record<string, unknown>) ? (value as T) : null
+  } catch {
+    return null
+  }
+}
+
+const isRead = (value: Record<string, unknown>) =>
+  typeof value.key === 'string' && typeof value.plansKey === 'string' && typeof value.snapshot === 'object'
+
+const isPlans = (value: Record<string, unknown>) =>
+  typeof value.plansKey === 'string' && typeof value.plans === 'object'
+
+const isBeat = (value: Record<string, unknown>) => typeof value.key === 'string' && typeof value.at === 'number'
+
+/**
+ * Where the herd files of the checkout at `root` lie: the watcher's directory, which only its user may read, beside the
+ * watcher's lock, which tells whether it still runs.
+ */
+export const herdFilesOf = (root: string): Record<keyof typeof HERD_FILES | 'lock', string> => {
+  const directory = watcherDirectoryOf(root)
+  return {
+    read: join(directory, HERD_FILES.read),
+    plans: join(directory, HERD_FILES.plans),
+    beat: join(directory, HERD_FILES.beat),
+    lock: join(directory, WATCHER_FILES.lock),
+  }
+}
+
+/** The published read; null for a missing, damaged or foreign file. */
+export const readHerdRead = (path: string): HerdRead | null => parsed<HerdRead>(readPrivateText(path), isRead)
+
+export const readHerdPlans = (path: string): HerdPlans | null => parsed<HerdPlans>(readPrivateText(path), isPlans)
+
+export const readHerdBeat = (path: string): HerdBeat | null => parsed<HerdBeat>(readPrivateText(path), isBeat)
+
+/** Writes a file through a temporary one, so a herd woken by the change never reads half of it. */
+export const writeHerdFile = (path: string, value: HerdRead | HerdPlans | HerdBeat): void =>
+  writePrivateFile(path, JSON.stringify(value))

package/src/plans/lane-reason.ts

@@ -2,7 +2,7 @@ import type { SprintLane } from '../plan-format'
 import { AGENT_STATUS, isRestingAgent } from '../terminal/types'
 import { REST_QUESTION_COUNT } from '../watch/lane-rest'
 import { waitingNote } from './lane-standing'
-import { plain } from './layout-phase'
+import { plain } from './markdown-text'
 import { shortTitle } from './task-name'
 import { TEXTS } from './texts'
 

package/src/plans/lane-summary.ts

@@ -2,6 +2,7 @@ import {
   isPhaseFinished,
   isPhaseOpen,
   type LaneProgress,
+  PHASE_WORK,
   type PhaseProgress,
   type PlanPhase,
   type PlansByHref,
@@ -130,6 +131,9 @@ const namedIds = ({ steps }: LaneProgress, href: string): Set<string> =>
     steps.flatMap(({ step }) => (step.planHref === href ? [...step.phaseIds, ...(step.namedPhaseIds ?? [])] : [])),
   )
 
+/** The base branch carries the phase's ticks: the worktree left them as they stand, or a run of it was merged. */
+const baseCarriesTicks = ({ work }: PhaseProgress): boolean => work === undefined || work === PHASE_WORK.merged
+
 /**
  * Whether a phase is a merged leftover: an older board row named it, the newest row does not, and the base branch
  * carries its ticks as they stand (not `touched`), so its open boxes were left open on purpose, or carries ticks of
@@ -140,7 +144,7 @@ const mergedLeftoverOf = ({ steps }: LaneProgress): IsLeftover => {
   const row = [...steps].reverse().find(({ step }) => !step.withoutRow)?.step
   if (!row) return () => false
   const rowIds = new Set(row.namedPhaseIds ?? row.phaseIds)
-  return (phase) => (phase.touched !== true || phase.merged === true) && !isNamedBy(phase.id, rowIds)
+  return (phase) => baseCarriesTicks(phase) && !isNamedBy(phase.id, rowIds)
 }
 
 /**
@@ -173,7 +177,7 @@ type IsLeftover = (phase: PhaseProgress) => boolean
  * its movement nor the latest movement makes it run. A leftover without that evidence still runs once it moves.
  */
 const isMergedRun = (phase: PhaseProgress, isLeftover: IsLeftover): boolean =>
-  phase.merged === true && isLeftover(phase)
+  phase.work === PHASE_WORK.merged && isLeftover(phase)
 
 /** What decides which open phases wait and in which order: the ids that run, and the merged leftovers. */
 type WaitingContext = { running: ReadonlySet<string>; isLeftover: IsLeftover }

package/src/plans/layout-phase.ts

@@ -8,6 +8,7 @@ import type { ActiveTask, UnplannedTask } from './active-tasks'
 import { type Frame, joinFrames, rowFrame, textFrame } from './frame'
 import type { LaneTickets } from './lane-tickets'
 import type { LinkChip } from './link-chips'
+import { plain } from './markdown-text'
 import type { PhaseModel } from './phase-models'
 import { itemKey, type Selection, taskRestKey } from './selection'
 import { shimmering, stillTeal } from './shimmer'
@@ -61,7 +62,6 @@ const COUNT_PLACES = 3
 const COUNT_MARK_WIDTH = 2
 const BLANK_COUNT = ' '.repeat(2 * COUNT_PLACES + 1)
 const COUNT_CELL_WIDTH = COUNT_MARK_WIDTH + 1 + BLANK_COUNT.length
-const MARKDOWN_MARKS = /\*\*|`/g
 const CODE_SPAN = /`([^`]+)`/g
 
 const PHASE_PAINT: Record<PhaseState, (count: string) => string> = {
@@ -78,8 +78,6 @@ const PHASE_MARK: Record<PhaseState, string> = {
   [PHASE_STATE.open]: '',
 }
 
-export const plain = (text: string): string => text.replace(MARKDOWN_MARKS, '')
-
 /** What a task reads as on one row: its short name where it carries one (`taskNameOf`), else its whole text. */
 export const taskTitle = (text: string): string => plain(taskNameOf(text) ?? text)
 

package/src/plans/layout-summary.ts

@@ -11,13 +11,13 @@ import {
   nowLine,
   phaseChildren,
   phaseCountCell,
-  plain,
   subagentLine,
   TASK_INDENT,
   type TaskStyle,
   taskRowFrame,
   taskTitle,
 } from './layout-phase'
+import { plain } from './markdown-text'
 import { type PhaseModel, phaseModelKey } from './phase-models'
 import { phaseRanges } from './phase-ranges'
 import { finishedKey, nextKey, phaseKey } from './selection'

package/src/plans/layout.ts

@@ -1,8 +1,9 @@
-import { TONE_ROLE } from '../config/tones'
+import { TONE, TONE_ROLE } from '../config/tones'
 import { CONTEXT_LEVEL, type ContextLevel, type ContextReading, contextLabel } from '../context'
 import type { LaneProgress, PhaseProgress } from '../plan-format'
 import { currentPhase, isPhaseOpen, phaseLabel } from '../plan-format'
 import type { WaitingItem } from '../plan-format/waiting'
+import { boundedMemo } from '../shared/bounded-memo'
 import {
   BADGE_TONE,
   type BadgeTone,
@@ -10,6 +11,7 @@ import {
   bar,
   box,
   bracket,
+  ESC,
   fit,
   link,
   packGroups,
@@ -51,7 +53,6 @@ import {
   type LaneContext,
   MIN_TITLE_WIDTH,
   nowLine,
-  plain,
   SHIMMERING_TASK,
   STILL_TASK,
   type TaskStyle,
@@ -59,6 +60,7 @@ import {
 import { foldedTaskLine, openLaneFrame } from './layout-summary'
 import { legendLines } from './legend'
 import { chipKey, type LinkChip, planUrlOf } from './link-chips'
+import { plain } from './markdown-text'
 import type { PhaseModel } from './phase-models'
 import { type PlannedPlan, plannedNextLabel } from './planned'
 import { CHECKS, type ChecksState, failedTestKey, type PullRequest, pullRequestKey } from './pull-requests'
@@ -205,8 +207,6 @@ type TopBlock = {
   /** What the head says after the count, painted, open and folded alike; empty for nothing. */
   balance: string
   markPaint: (text: string) => string
-  /** The paint of the buttons of a row: amber for "Your turn", the normal foreground colour elsewhere. */
-  buttonPaint: (text: string) => string
   /** Whether a row is the selected one or under the mouse: it gets the background, the mark, and its buttons. */
   focused: (key: string) => boolean
   /** Whether all buttons of a row are bold: the arrows selected it and the mouse is not on it (the mouse bolds one). */
@@ -495,17 +495,11 @@ const TALLY_SEPARATOR = ' · '
 /** How many cut chip labels the render keeps; a label is often a whole line of a plan, measured anew every frame otherwise. */
 const KEPT_LABELS = 2000
 
-const cutLabels = new Map<string, string>()
+const cutLabels = boundedMemo<string, string>(KEPT_LABELS)
 
 /** The chip label cut to `CHIP_LABEL_WIDTH`, kept per label; the kept ones are dropped all at once when they are too many. */
-const cutLabel = (label: string): string => {
-  const kept = cutLabels.get(label)
-  if (kept !== undefined) return kept
-  if (cutLabels.size >= KEPT_LABELS) cutLabels.clear()
-  const cut = fit(plain(label), CHIP_LABEL_WIDTH)
-  cutLabels.set(label, cut)
-  return cut
-}
+const cutLabel = (label: string): string =>
+  cutLabels.get(label) ?? cutLabels.set(label, fit(plain(label), CHIP_LABEL_WIDTH))
 
 /** `[🔗 label]` linked to the chip's address, `private` faint inside it for a link its plan says is private. */
 const chipCell = ({ url, icon, label, private: hidden }: LinkChip): string =>
@@ -1012,6 +1006,9 @@ const plannedRows = (planned: PlannedPlan[], width: number, indent: string): str
 
 const rule = (width: number): string => paint.dim(RULE.repeat(width))
 
+/** The one colour of the buttons of "Your turn" and "Sources" (`[ask]`, `[done]`, `[run]`, `[move]`). */
+const ACTION_PAINT = paintOfTone(TONE.teal)
+
 /** The blank that starts every line of a block on top: no bar, the mark of a row says what it is. */
 const blockBar = (): string => ' '
 
@@ -1033,35 +1030,41 @@ const markedLine = (line: string, row: BlockRow, markPaint: (text: string) => st
   return line.startsWith(row.mark) ? `${paintMark(row.mark)}${line.slice(row.mark.length)}` : line
 }
 
-/** The text from `from` on dimmed, without the blanks that pad it to the right edge. */
+/**
+ * The text from `from` on dimmed, without the blanks that pad it to the right edge. `from` counts in the line the row
+ * measured it on; a line cut shorter for the buttons (`row.hot`) ends in a colour code, and a `from` past its start
+ * would tear that code, so such a line stays undimmed from there.
+ */
 const dimmedRest = (text: string, from: number): string => {
-  const end = text.trimEnd().length
+  const code = text.indexOf(ESC)
+  const end = code === -1 || from < code ? text.trimEnd().length : from
   return from >= end ? text : `${text.slice(0, from)}${paint.dim(text.slice(from, end))}${text.slice(end)}`
 }
 
 /**
  * One row as lines: the bar on each, the mark painted on the first line only, the short title in the normal colour
- * and the rest of an expanded row dim, linked when the row has an address. The buttons at the end of the first line
- * are drawn only on the focused row, in the block's button paint; they keep their columns on every row.
+ * and the rest of an expanded row dim, linked when the row has an address. The text takes the whole pane; only the
+ * row under the selection or the mouse draws its buttons, in the action colour (`ACTION_PAINT`), flush right at the
+ * edge of its first line, over the end of its text (`row.hot`) and, in "Your turn", its time.
  */
-const blockRowLines = (
-  { markPaint, buttonPaint, focused, allBold }: TopBlock,
-  row: BlockRow,
-  width: number,
-): string[] => {
+const blockRowLines = ({ markPaint, focused, allBold }: TopBlock, row: BlockRow, width: number): string[] => {
   const hot = focused(row.key)
-  const paintButton = (text: string) => (allBold(row.key) ? paint.bold(buttonPaint(text)) : buttonPaint(text))
+  const paintButton = (text: string) => (allBold(row.key) ? paint.bold(ACTION_PAINT(text)) : ACTION_PAINT(text))
   return row.lines.map((line, index) => {
-    const withButton = hot && index === 0 && row.buttons.length > 0
-    const styled = dimmedRest(line, row.dimFrom[index] ?? line.length)
-    const marked = index === 0 ? markedLine(styled, row, markPaint) : styled
-    const shown = row.url ? link(row.url, marked) : marked
-    const buttons = withButton ? buttonsText(row.buttons, row.dim ? paint.dim : paintButton) : ''
+    const covered = hot && index === 0 ? row.hot : undefined
+    const shown = rowText(row, covered ?? line, index, markPaint)
+    const buttons = covered === undefined ? '' : ` ${buttonsText(row.buttons, row.dim ? paint.dim : paintButton)}`
     const drawn = `${blockBar()} ${shown}${buttons}`
     return hot ? focusLine(drawn, width, index === 0) : drawn
   })
 }
 
+/** The text of a row's line `index`: dim from its `dimFrom` on, the mark painted on the first line, linked to its address. */
+const rowText = (row: BlockRow, text: string, index: number, markPaint: (text: string) => string): string => {
+  const styled = dimmedRest(text, row.dimFrom[index] ?? text.length)
+  const marked = index === 0 ? markedLine(styled, row, markPaint) : styled
+  return row.url ? link(row.url, marked) : marked
+}
 /** A folded block: its head alone, which keeps the count and the balance; a click matches no row and no `+<n>` line. */
 const foldedBlockLines = (block: TopBlock, headKey: string, width: number): BlockLines => ({
   open: false,
@@ -1132,14 +1135,13 @@ const yourTurnLines = ({ turn, now }: YourTurnBlock, state: Selection, width: nu
     count,
     balance: balanceText(turnBalance(turn, clock)),
     markPaint: turnMarkPaint,
-    buttonPaint: paintOfRole(TONE_ROLE.waiting),
     focused: (key) => isFocused(state, key),
     allBold: (key) => buttonsAllBold(state, key),
     countPaint: turn.now.length > 0 ? paintOfRole(TONE_ROLE.waiting) : (text) => text,
     moreKey: null,
     hidden: 0,
     expanded: false,
-    rows: turnRows(turnPage(turn, opened, clock), width),
+    rows: turnRows(turnPage(turn, opened, clock), width, state.expanded),
   }
   return blockLinesOf(block, state, TOP_BLOCK.yourTurn, width)
 }
@@ -1169,7 +1171,6 @@ const sourceLines = (
     count: null,
     balance: sourceSummaryText(sourceSummaries(sources, now, newTone, asked)),
     markPaint: paint.dim,
-    buttonPaint: (text) => text,
     focused: (key) => isFocused(state, key),
     allBold: (key) => buttonsAllBold(state, key),
     countPaint: (text) => text,

package/src/plans/link-chips.ts

@@ -1,4 +1,6 @@
 import { ARTIFACT_LINK_KIND, type LinkKind } from '../config/link-kinds'
+import { type BoundedMemo, boundedMemo } from '../shared/bounded-memo'
+import { plain } from './markdown-text'
 
 /** A link of a plan that matches a link kind, as the sprint page shows it. */
 export type LinkChip = { url: string; label: string; icon: string; private: boolean }
@@ -10,7 +12,6 @@ const AUTOLINK = /<(https?:\/\/[^>\s]+)>/g
 const BARE_LINK = /(?<![<\w"])(https?:\/\/[^\s)>\]]+)/g
 const LABEL_BEFORE = /\*\*([^*]+?):?\*\*:?\s*(?:[-–>]\s*)?$/
 const PRIVATE = /\bprivat/i
-const MARKS = /\*\*|`/g
 const CONTROL = /\p{Cc}/gu
 
 const linksOf = (line: string): Found[] => {
@@ -33,19 +34,14 @@ 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 =>
-  line
-    .replace(MARKDOWN_LINK, '$1')
-    .replace(AUTOLINK, '')
-    .replace(LEFTOVER_LINK, '')
-    .replace(LIST_LEAD, '')
-    .replace(MARKS, '')
+  plain(line.replace(MARKDOWN_LINK, '$1').replace(AUTOLINK, '').replace(LEFTOVER_LINK, '').replace(LIST_LEAD, ''))
     .replace(CONTROL, '')
     .replace(TITLE_END, '')
     .trim()
 
 const labelOf = (found: Found, kind: LinkKind): string => {
   const written = found.text ?? LABEL_BEFORE.exec(found.before)?.[1]
-  const own = written?.replace(MARKS, '').replace(CONTROL, '').trim()
+  const own = written && plain(written).replace(CONTROL, '').trim()
   if (own) return own
   return (kind.pattern === ARTIFACT_LINK_KIND.pattern && lineTitleOf(found)) || kind.label
 }
@@ -53,7 +49,7 @@ const labelOf = (found: Found, kind: LinkKind): string => {
 /** 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[]>>()
+const keptChips = new WeakMap<readonly LinkKind[], BoundedMemo<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[] => {
@@ -81,14 +77,9 @@ export const readLinkChips = (markdown: string, kinds: readonly LinkKind[]): Lin
  * 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[]>()
+  const byText = keptChips.get(kinds) ?? boundedMemo<string, LinkChip[]>(KEPT_TEXTS)
   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
+  return byText.get(markdown) ?? byText.set(markdown, readLinkChips(markdown, kinds))
 }
 
 const CHIP_KEY = /^chip>(https?:\/\/.+)$/