jackherd 1.8.1 → 1.10.0

package/src/plans/layout.ts

@@ -1,6 +1,7 @@
 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 {
   BADGE_TONE,
   type BadgeTone,
@@ -8,6 +9,7 @@ import {
   bar,
   box,
   fit,
+  link,
   packGroups,
   padVisible,
   paint,
@@ -17,7 +19,6 @@ import {
 } from '../terminal/text'
 import { AGENT_STATUS, type AgentStatus, isAgentStatus } from '../terminal/types'
 import { textWidth } from '../terminal/width'
-import { PLAN_LANGUAGE } from '../vocabulary'
 import {
   NO_BADGES,
   type PullRequestBadges,
@@ -26,28 +27,55 @@ import {
   type WatchBadges,
   type WatchHealth,
 } from '../watch/plan-badges'
+import type { UnplannedTask } from './active-tasks'
+import { type AppointmentBlock, appointmentItems, appointmentKeys } from './appointment-rows'
 import { deeper, type Frame, joinFrames, nest, prefixed, rowFrame, TREE, textFrame } from './frame'
 import { LANE_STANDING, type LaneStanding, laneStanding, waitingNote } from './lane-standing'
 import { type LaneSummary, laneSummary } from './lane-summary'
-import type { LaneTickets } from './lane-tickets'
-import { COLUMN_SEPARATOR, countCell, countText, type LaneContext, MIN_TITLE_WIDTH, plain } from './layout-phase'
-import { summaryChildren } from './layout-summary'
+import { type LaneTickets, withoutTicketKey } from './lane-tickets'
+import {
+  COLUMN_SEPARATOR,
+  countCell,
+  countText,
+  type LaneContext,
+  MIN_TITLE_WIDTH,
+  nowLine,
+  plain,
+} from './layout-phase'
+import { foldedTaskLine, summaryChildren } from './layout-summary'
 import { chipKey, type LinkChip, planUrlOf } from './link-chips'
 import type { PhaseModel } from './phase-models'
 import { type PlannedPlan, phaseList, plannedPhaseCount } from './planned'
-import { CHECKS, type ChecksState, type PullRequest, pullRequestKey } from './pull-requests'
+import { CHECKS, type ChecksState, failedTestKey, type PullRequest, pullRequestKey } from './pull-requests'
 import {
   type ClickTarget,
+  isBlockFolded,
   isLaneOpen,
   laneKey,
   PLANNED_KEY,
   type Selection,
   selectedKey,
+  TOP_BLOCK,
+  type TopBlockId,
   targetKeys,
 } from './selection'
+import type { SentChip } from './sent-files'
 import { shownWithMore } from './shown-with-more'
-import { chevronOf, NO_AGENT_SYMBOL, NO_AGENT_WORD, statusSymbol, statusWord } from './symbols'
+import { chevronOf, LESS_MARK, NO_AGENT_SYMBOL, statusSymbol, statusWord } from './symbols'
 import { BADGE_TEXTS, type BadgeTexts, checksText, laneMarkText, TEXTS } from './texts'
+import {
+  APPOINTMENT_MORE_KEY,
+  ASK_BUTTON,
+  type BlockHit,
+  type BlockRow,
+  blockRows,
+  moreKeyOf,
+  SHOWN_BLOCK_ROWS,
+  WAITING_MARK,
+  WAITING_MORE_KEY,
+  waitingKeys,
+  waitingRows,
+} from './waiting-click'
 
 /**
  * Where a lane stands outside its plan. `agent` is the terminal adapter's status, null when no agent is listed;
@@ -78,6 +106,8 @@ export type LaneView = {
   tickets?: LaneTickets
   /** The model each phase's implementing subagent last ran on, by `phaseModelKey`; absent without a record. */
   models?: Record<string, PhaseModel>
+  /** The files this lane's session sent to the user, shown as badges on the row of link chips. */
+  sentFiles?: SentChip[]
 }
 
 /** `watch` is the health of the watcher the badges come from, absent when it was not read. */
@@ -89,10 +119,26 @@ export type OverviewView = {
   watch?: WatchHealth
   /** True when the config marks a ticket source, so a missing watcher is said without a pull request too. */
   watchesTickets?: boolean
+  /** The open items of the board's section of what waits on the user, shown under the title. */
+  awaiting?: WaitingItem[]
+  /** The open appointments of the board, in a block of their own under the for-you block. */
+  appointments?: AppointmentBlock
+  /** What agents report doing that no lane takes, one `now:` line each under the title. */
+  unplaced?: UnplannedTask[]
 }
 
-/** A fixed header and footer around a body that scrolls; body lines and targets count from the body's top. */
-export type Screen = { header: string[]; body: Frame; footer: string[] }
+/**
+ * The drawn screen: a fixed header and footer around a body that scrolls; body lines and targets count from the body's
+ * top. `waitingBlock` and `appointmentBlock` are what a click on the for-you and the appointment block is matched
+ * against, null while the block is not drawn.
+ */
+export type Screen = {
+  header: string[]
+  body: Frame
+  footer: string[]
+  waitingBlock: BlockHit | null
+  appointmentBlock: BlockHit | null
+}
 
 /**
  * Widths shared by every lane line: the name column, the folded pull request badges, and bar with context. They are
@@ -102,7 +148,33 @@ export type Screen = { header: string[]; body: Frame; footer: string[] }
  */
 type LaneColumns = { name: number; marks: number; right: number; phases: boolean; tally: number }
 
+/**
+ * The lines of a block on top of the herd; the head of an open one is a rule of its own, a folded one is a plain line.
+ * `hit` is what a click on it is matched against, without the screen line the stack gives it.
+ */
+type BlockLines = { open: boolean; lines: string[]; hit: Omit<BlockHit, 'firstLine'> }
+
+/**
+ * What a block of the top of the herd is drawn from: its name, the bar of its lines, the paint of the mark that starts
+ * a row, the key of its `+<n>` line, its points and their rows.
+ */
+type TopBlock = {
+  name: string
+  bar: () => string
+  markPaint: (text: string) => string
+  /** The paint of the count in the head while the block has points: amber for what waits on the user. */
+  countPaint: (text: string) => string
+  moreKey: string
+  expanded: boolean
+  keys: readonly string[]
+  rows: BlockRow[]
+}
+
+/** The blocks on top of the herd one under the other: their lines below the title, and the hit of each drawn block. */
+type BlockStack = { lines: string[]; hits: (BlockHit | null)[] }
+
 const BRANCH_MARK = '⎇'
+const SENT_MARK = '📎'
 const SYMBOL_WIDTH = 2
 const NAME_WIDTH_MAX = 24
 const NON_BREAKING_SPACE = '\u00a0'
@@ -114,30 +186,26 @@ const CONTEXT_WIDTH = 5
 /** The context cell at the right of the session line: symbol, share and a cell of space. */
 const CONTEXT_CELL_WIDTH = CONTEXT_WIDTH + 3
 const CONTEXT_SYMBOL = '🥣'
-const PROGRESS_SYMBOL = '◐'
 const HEADER_MARK = '🐾'
 const COLUMN_RULE = '│'
 /** The number badge of a three-digit pull request (`↗ #` and the digits, a cell of padding either side); a longer one widens it. */
 const PULL_REQUEST_BADGE_WIDTH = 8
 /**
- * Under the lane line's status symbol: where the pull request row and its badge line start (D96), and where the trunk
+ * Under the lane line's status symbol: where the pull request row and its badge line start, and where the trunk
  * of an open lane hangs, not under the fold arrow.
  */
 const UNDER_STATUS = '  '
 const CHECKS_WIDTH = 10
 /** The most failed tests listed under a pull request; the rest is counted. */
 const SHOWN_FAILED_TESTS = 3
-const FAILED_TEST_INDENT = '     '
-
-/** Lower ranks need the coordinator sooner; a status an adapter adds later ranks after `working`. */
-const URGENCY: Record<AgentStatus, number> = {
-  [AGENT_STATUS.blocked]: 0,
-  [AGENT_STATUS.done]: 1,
-  [AGENT_STATUS.idle]: 1,
-  [AGENT_STATUS.working]: 2,
-}
-const UNKNOWN_URGENCY = 3
-const NO_AGENT_URGENCY = 4
+const FAILED_MARK = '✗'
+/** The tree under a check chip, one cell narrower than the lane's: the chip's children are short. */
+const FAILED_TREE = { branch: '├ ', last: '└ ', pipe: '│ ', gap: '  ' } as const
+/** An unfolded failed test's lines after its first hang under the name, past the mark. */
+const FAILED_HANG = '  '
+const TEST_PATH_LEVEL = ' > '
+const TEST_PATH_SEPARATOR = ' › '
+const PLACE_SEPARATOR = ' · '
 
 /** The colour of a lane state, word and symbol alike: teal while working or done, bold amber when it waits for you, grey when idle. */
 const STATUS_PAINT: Record<AgentStatus, (text: string) => string> = {
@@ -154,19 +222,9 @@ const CHECKS_PAINT: Record<ChecksState, (text: string) => string> = {
   [CHECKS.none]: paint.dim,
 }
 
-const urgencyOf = ({ status }: LaneView): number => {
-  if (status.agent === null) return NO_AGENT_URGENCY
-  return isAgentStatus(status.agent) ? URGENCY[status.agent] : UNKNOWN_URGENCY
-}
-
-/** Lanes waiting for input first, then those with a report to read, then working ones; stable inside a group. */
-export const sortByUrgency = (lanes: readonly LaneView[]): LaneView[] =>
-  [...lanes].sort((left, right) => urgencyOf(left) - urgencyOf(right))
-
-const agentLabel = (agent: string | null): string => {
-  if (agent === null) return paint.dim(statusWord(agent))
-  return isAgentStatus(agent) ? STATUS_PAINT[agent](statusWord(agent)) : statusWord(agent)
-}
+/** Only a blocked agent is named in the lane line, since there the user must act; the symbol says the rest. */
+const agentLabel = (agent: string | null): string =>
+  agent === AGENT_STATUS.blocked ? STATUS_PAINT[AGENT_STATUS.blocked](statusWord(agent)) : ''
 
 /** The symbol of a status padded to `SYMBOL_WIDTH` cells, so the names after it start in one column. */
 const symbolCell = (agent: string | null): string => {
@@ -179,15 +237,14 @@ const symbolCell = (agent: string | null): string => {
 
 const aheadLabel = ({ branch, ahead }: LaneStatus): string => {
   if (ahead === null) return branch ? paint.dim('↑?') : ''
-  return ahead > 0 ? paint.cyan(`↑${ahead}`) : ''
+  return ahead > 0 ? paint.teal(`↑${ahead}`) : ''
 }
 
+const branchLabel = (status: LaneStatus): string =>
+  status.branch ? paint.dim(`${BRANCH_MARK} ${status.branch}`) : paint.dim(TEXTS.noWorktree)
+
 const gitLabel = (status: LaneStatus): string =>
-  [
-    status.branch ? paint.dim(`${BRANCH_MARK} ${status.branch}`) : paint.dim(TEXTS.noWorktree),
-    aheadLabel(status),
-    status.dirty ? paint.magenta(`±${status.dirty}`) : '',
-  ]
+  [branchLabel(status), aheadLabel(status), status.dirty ? paint.magenta(`±${status.dirty}`) : '']
     .filter(Boolean)
     .join(' ')
 
@@ -229,18 +286,26 @@ export const rowWithCount = (
 const fitsBeside = (head: string, cells: BadgeCell[], width: number): boolean =>
   visibleLength(head) + packedWidth(cells) + COLUMN_SEPARATOR.length + MIN_TITLE_WIDTH <= width
 
+/** The number of a pull request as a badge linked to it, padded to its column. */
+const numberCell = (pullRequest: PullRequest): string =>
+  padVisible(badge(pullRequest.url, `↗ #${pullRequest.number}`), PULL_REQUEST_BADGE_WIDTH)
+
+/** The column the check chip of a pull request row starts in, behind its number. */
+const checksColumnOf = (pullRequest: PullRequest): number =>
+  visibleLength(numberCell(pullRequest)) + COLUMN_SEPARATOR.length
+
 /**
  * `⟦↗ #<number>⟧  ✓ checks  ⟦🌐 preview⟧ ⟦💬 3 new⟧  title`: the number as a badge and the check state in fixed
  * columns, the watcher's badges after them and the title last, cut with `…` on its one line. When the badges leave no
- * room for a title, they go on lines of their own below, starting in the column of the lane's status symbol (D96).
+ * room for a title, they go on lines of their own below, starting in the column of the lane's status symbol.
  */
 const pullRequestRow = (pullRequest: PullRequest, context: LaneContext): Frame => {
-  const number = padVisible(badge(pullRequest.url, `↗ #${pullRequest.number}`), PULL_REQUEST_BADGE_WIDTH)
+  const number = numberCell(pullRequest)
   const checksWords = checksText(pullRequest)
   const checksColumn =
     textWidth(checksWords) < CHECKS_WIDTH ? CHECKS_WIDTH : textWidth(checksWords) + COLUMN_SEPARATOR.length
   const checks = padVisible(CHECKS_PAINT[pullRequest.checks](checksWords), checksColumn)
-  const head = `${UNDER_STATUS}${number}${COLUMN_SEPARATOR}${checks}`
+  const head = `${number}${COLUMN_SEPARATOR}${checks}`
   const prefix = pullRequest.draft ? TEXTS.draft : ''
   const dimPrefix = (line: string, index: number) =>
     index === 0 && prefix ? `${paint.dim(prefix)}${line.slice(prefix.length)}` : line
@@ -248,8 +313,8 @@ const pullRequestRow = (pullRequest: PullRequest, context: LaneContext): Frame =
   const key = pullRequestKey(pullRequest.number)
   if (cells.length === 0 || !fitsBeside(head, cells, context.width))
     return joinFrames([
-      rowFrame(key, besideHead(head, `${prefix}${pullRequest.title}`, context.width, dimPrefix), [], context),
-      packedFrame(cells, UNDER_STATUS, context.width),
+      rowFrame(key, [fit(`${head}${dimPrefix(`${prefix}${pullRequest.title}`, 0)}`, context.width)], [], context),
+      packedFrame(cells, '', context.width),
     ])
   const beside = `${head}${cells.map(({ cell }) => cell).join(CHIP_GAP)}${COLUMN_SEPARATOR}`
   const row = rowFrame(
@@ -261,22 +326,75 @@ const pullRequestRow = (pullRequest: PullRequest, context: LaneContext): Frame =
   return { ...row, targets: [...cellTargets(cells, 0, visibleLength(head), context.width), ...row.targets] }
 }
 
-/** The failed tests of a red pull request, at most `SHOWN_FAILED_TESTS` of them one per line, then `+<n>`; none otherwise. */
-const failedTestLines = (pullRequest: PullRequest, badges: PullRequestBadges | undefined, width: number): string[] => {
+/** `✗ <place> · <path>` as plain text, each ` > ` of the test path as ` › `; without a place `✗ <path>`. */
+const failedTestText = (name: string, place: string | null): string => {
+  const path = plain(name).replaceAll(TEST_PATH_LEVEL, TEST_PATH_SEPARATOR)
+  return place ? `${FAILED_MARK} ${plain(place)}${PLACE_SEPARATOR}${path}` : `${FAILED_MARK} ${path}`
+}
+
+/** The first line of a failed test painted: mark and place red, separator and test path dim. */
+const paintFailedTest = (line: string, place: string | null): string => {
+  const head = place ? `${FAILED_MARK} ${plain(place)}` : FAILED_MARK
+  if (!line.startsWith(head)) return paint.dim(line)
+  const lead = place ? `${paint.red(FAILED_MARK)} ${paint.red(plain(place))}` : paint.red(FAILED_MARK)
+  const rest = line.slice(head.length)
+  const separator = place && rest.startsWith(PLACE_SEPARATOR) ? PLACE_SEPARATOR : ''
+  return `${lead}${separator ? paint.dim(separator) : ''}${paint.dim(rest.slice(separator.length))}`
+}
+
+/** One child of the check chip: its tree branch (`├`, `└` for the last) and what carries on beside it. */
+type FailedBranch = { first: string; rest: string }
+
+const failedBranch = (last: boolean): FailedBranch =>
+  last ? { first: FAILED_TREE.last, rest: FAILED_TREE.gap } : { first: FAILED_TREE.branch, rest: FAILED_TREE.pipe }
+
+/**
+ * A failed test under the check chip (`column`): cut to one line, which a click unfolds over several, the name hanging
+ * under its first word, and a second click folds; a name that fits is no click target.
+ */
+const failedTestFrame = (
+  test: { name: string; place: string | null; key: string },
+  branch: FailedBranch,
+  column: number,
+  context: LaneContext,
+): Frame => {
+  const indent = ' '.repeat(column)
+  const room = Math.max(context.width - column - textWidth(branch.first), 1)
+  const text = failedTestText(test.name, test.place)
+  const cut = textWidth(text) > room
+  const [first = '', ...rest] =
+    cut && context.state.expanded.has(test.key) ? wrap(text, Math.max(room - FAILED_HANG.length, 1)) : [fit(text, room)]
+  const lines = [
+    `${indent}${paint.dim(branch.first)}${paintFailedTest(first, test.place)}`,
+    ...rest.map((line) => `${indent}${paint.dim(branch.rest)}${FAILED_HANG}${paint.dim(line)}`),
+  ]
+  return cut ? rowFrame(test.key, lines, [], context) : textFrame(lines)
+}
+
+/**
+ * The failed tests of a red pull request as children of its check chip, at most `SHOWN_FAILED_TESTS`, then `+<n>`;
+ * the package of each first when the watcher read it from the log. None for a pull request that is not red.
+ */
+const failedTestsFrame = (pullRequest: PullRequest, context: LaneContext): Frame => {
+  const badges = context.badges[String(pullRequest.number)]
   const tests = pullRequest.checks === CHECKS.failed ? (badges?.failedTests ?? []) : []
   const { shown, more } = shownWithMore(tests, SHOWN_FAILED_TESTS)
-  const lines = shown.map((name) => `${FAILED_TEST_INDENT}${paint.red(`✗ ${plain(name)}`)}`)
-  return [...lines, ...(more > 0 ? [`${FAILED_TEST_INDENT}${paint.dim(`+${more}`)}`] : [])].map((line) =>
-    fit(line, width),
+  const column = checksColumnOf(pullRequest)
+  const frames = shown.map((name, index) =>
+    failedTestFrame(
+      { name, place: badges?.failedTestPlaces?.[name] ?? null, key: failedTestKey(pullRequest.number, index) },
+      failedBranch(more === 0 && index === shown.length - 1),
+      column,
+      context,
+    ),
   )
+  const moreLine = `${' '.repeat(column)}${paint.dim(`${FAILED_TREE.last}+${more}`)}`
+  return joinFrames([...frames, ...(more > 0 ? [textFrame([fit(moreLine, context.width)])] : [])])
 }
 
 /** The pull request row, then the tests its red checks failed, which only the watcher knows. */
 const pullRequestFrame = (pullRequest: PullRequest, context: LaneContext): Frame =>
-  joinFrames([
-    pullRequestRow(pullRequest, context),
-    textFrame(failedTestLines(pullRequest, context.badges[String(pullRequest.number)], context.width)),
-  ])
+  joinFrames([pullRequestRow(pullRequest, context), failedTestsFrame(pullRequest, context)])
 
 const CONTEXT_PAINT: Record<ContextLevel, (text: string) => string> = {
   [CONTEXT_LEVEL.ok]: paint.dim,
@@ -288,17 +406,24 @@ const CONTEXT_PAINT: Record<ContextLevel, (text: string) => string> = {
 const contextValue = (context: ContextReading | null | undefined): string =>
   context ? `${CONTEXT_SYMBOL}${CONTEXT_PAINT[context.level](contextLabel(context.share).padStart(CONTEXT_WIDTH))}` : ''
 
-/** The context value with a rule before the bar that follows it on a folded lane line; empty without a reading. */
-const contextCell = (context: ContextReading | null | undefined): string =>
-  context ? `${contextValue(context)} ${paint.dim(COLUMN_RULE)} ` : ''
+/**
+ * The context value with a rule before the bar that follows it on a folded lane line, from `warn` on; below, blanks
+ * as wide, so nothing moves when it shows. Empty without a reading.
+ */
+const contextCell = (context: ContextReading | null | undefined): string => {
+  if (!context) return ''
+  const cell = `${contextValue(context)} ${paint.dim(COLUMN_RULE)} `
+  return context.level === CONTEXT_LEVEL.ok ? ' '.repeat(visibleLength(cell)) : cell
+}
 
 /**
  * Bar, checkbox count and phase count over the lane's plans in a fixed-width column, so every bar on screen starts in
- * the same column: `██░░ ◐  50/213 · 4/14 ph`. The phase count stands right-aligned in `tallyWidth` cells behind the
- * `·`, the widest of the lanes on screen, so a shorter one moves neither bar nor `·`; at 0 it is left out.
+ * the same column: `██░░   50/213 · 4/14 ph`, folded or open. The phase count stands right-aligned in `tallyWidth`
+ * cells behind the `·`, the widest of the lanes on screen, so a shorter one moves neither bar nor `·`; at 0 it is
+ * left out.
  */
 const progressColumn = ({ done, total, phasesDone, phases }: LaneSummary['tally'], tallyWidth: number): string => {
-  const counts = `${bar(done, total)} ${countCell(PROGRESS_SYMBOL, countText(done, total))}`
+  const counts = `${bar(done, total)} ${countCell('', countText(done, total))}`
   if (tallyWidth === 0) return counts
   const tally = TEXTS.phaseTally(phasesDone, phases)
   const padding = ' '.repeat(Math.max(tallyWidth - visibleLength(tally), 0))
@@ -377,23 +502,29 @@ const ticketCells = (tickets: LaneTickets | null): BadgeCell[] => {
   return [...tickets.shown.map(ticketCell), ...more]
 }
 
+/** A file the lane's session sent to the user, `📎 name` linked by its `file:` address; the terminal opens it, no click of ours does. */
+const sentCell = ({ url, label }: SentChip): BadgeCell => ({
+  cell: badge(url, `${SENT_MARK} ${plain(label)}`),
+  key: null,
+})
+
 const chipCellOf = (chip: LinkChip): BadgeCell => ({ cell: chipCell(chip), key: chipKey(chip.url) })
 
-/** The chips of the lane's plans behind a 📎, each once, the plan chips first and the tickets beside them. */
-const chipFrame = (chips: LinkChip[], tickets: LaneTickets | null, width: number): Frame => {
+/** The chips of the lane's plans, each once, the plan chips first, the tickets beside them, the sent files last. */
+const chipCells = (chips: LinkChip[], tickets: LaneTickets | null, sent: readonly SentChip[] = []): BadgeCell[] => {
   const isPlanChip = (chip: LinkChip) => planUrlOf(chipKey(chip.url)) !== null
   const unique = chips.filter((chip, index) => chips.findIndex(({ url }) => url === chip.url) === index)
-  const cells = [
+  return [
     ...unique.filter(isPlanChip).map(chipCellOf),
     ...ticketCells(tickets),
     ...unique.filter((chip) => !isPlanChip(chip)).map(chipCellOf),
+    ...sent.map(sentCell),
   ]
-  return packedFrame(cells, '', width)
 }
 
 /**
  * `🌐 preview` opening the preview, `💬 <n> new` in amber opening the pull request, and `✋ changes requested` in dark
- * red opening it too, each only when there is one (D96).
+ * red opening it too, each only when there is one.
  */
 const badgeCells = (
   pullRequest: PullRequest,
@@ -412,19 +543,18 @@ const badgeCells = (
   ]
 }
 
-/** The columns lane lines share, so names, statuses and bars of all of them line up. */
-const STATUS_WIDTH = Math.max(...[...Object.values(AGENT_STATUS), NO_AGENT_WORD].map(textWidth))
-
 /**
- * The phase the lane line names: the open phase moved last, else the lane's current phase while it is open; never one
- * ticked to the end, whose state DONE says (`not merged`). Null when there is neither.
+ * The phase the lane line names: the one its report or branch signals, else the open phase moved last, else the
+ * lane's current phase while it is open; never one ticked to the end, whose state the `✓` line says. Null when there
+ * is none.
  */
 const headPhase = (view: LaneView): PhaseProgress | null => {
+  const { signalled, latest } = summaryOf(view)
   const current = currentPhase(view.progress)
-  return summaryOf(view).latest ?? (current && isPhaseOpen(current) ? current : null)
+  return signalled ?? latest ?? (current && isPhaseOpen(current) ? current : null)
 }
 
-/** `P9 Freigabe 0.x` for the phase the lane line names; empty when there is none. */
+/** `P9 Release 1.0` for the phase the lane line names; empty when there is none. */
 const nextPhaseLabel = (view: LaneView): string => {
   const phase = headPhase(view)
   return phase ? `${phaseLabel(phase.id)}${phase.title ? ` ${plain(phase.title)}` : ''}` : ''
@@ -457,17 +587,28 @@ const ticketMark = (tickets: LaneTickets | undefined): string[] => {
 const laneMarks = ({ pullRequests, badges, tickets }: LaneView): string =>
   [...pullRequests.map((pullRequest) => pullRequestMark(pullRequest, badges ?? {})), ...ticketMark(tickets)].join(' ')
 
-/** What follows the status on a lane line, open or folded: the phase it works on; the branch is on the session line. */
-const laneDetail = (view: LaneView): string => {
+/**
+ * `P3 Search API +1 · 12/20` for a folded lane: the phase it names, `+n` for the other active phases, the phase's
+ * ticked boxes. An open lane names it on a phase branch, so its own line does not.
+ */
+const foldedPhaseLabel = (view: LaneView): string => {
+  const phase = headPhase(view)
+  if (!phase) return ''
+  const more = summaryOf(view).active.filter((active) => active.phase.id !== phase.id).length
+  return `${nextPhaseLabel(view)}${more > 0 ? ` +${more}` : ''} · ${phase.done}/${phase.total}`
+}
+
+/** What follows the status on a lane line: the marker and, folded only, the phase it works on; the branch is on the session line. */
+const laneDetail = (view: LaneView, open: boolean): string => {
   const markText = laneMarkText(view)
   const marker = markText ? paint.yellow(markText) : ''
-  return [marker, nextPhaseLabel(view)].filter(Boolean).join(' ')
+  return [agentLabel(view.status.agent), marker, open ? '' : foldedPhaseLabel(view)].filter(Boolean).join(' ')
 }
 
 /**
  * The lane line, `head` and `right` (bar and count) at the edges. The detail (next phase, branch, pull
  * requests) follows `head` when at least `MIN_BESIDE_WIDTH` characters are left for it; in a narrower pane
- * it moves to a line of its own below, behind `indent` (three cells, the trunk of an open lane) and cut to the full width.
+ * it moves to a line of its own below, behind `indent` (`detailIndent`: up to the name column) and cut to the full width.
  */
 export const withDetail = (
   head: string,
@@ -484,10 +625,9 @@ export const withDetail = (
 
 /** 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: {}, texts: {}, activity: {}, language: PLAN_LANGUAGE.en }, 0)
+  view.summary ?? laneSummary({ progress: view.progress, phases: {}, activity: {} }, 0)
 
-/** The bar over the lane's plans, empty while they have no checkbox. */
+/** The bar and checkbox count over the lane's plans; empty while they have no checkbox. */
 const laneProgressColumn = (view: LaneView, tallyWidth: number): string => {
   const { tally } = summaryOf(view)
   return tally.total > 0 ? progressColumn(tally, tallyWidth) : ''
@@ -502,7 +642,7 @@ 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 (D96). */
+/** A folded lane's marks in the column of `columns.marks`, right before context and bar. */
 const markedRight = (view: LaneView, columns: LaneColumns): string => {
   const right = laneRight(view, tallyWidthOf(columns))
   const marks = laneMarks(view)
@@ -512,39 +652,96 @@ const markedRight = (view: LaneView, columns: LaneColumns): string => {
   return `${padVisible(marks, columns.marks)}${COLUMN_SEPARATOR}${pad}${right}`
 }
 
+/**
+ * Before a lane's detail on a line of its own: blanks up to the column of the lane's name, so a folded lane's title
+ * starts where its name does, as the branches of an open lane do; an open lane keeps its trunk in front.
+ */
+const detailIndent = (open: boolean, nameColumn: number): string => {
+  if (!open) return ' '.repeat(nameColumn)
+  const trunk = `${UNDER_STATUS}${TREE.pipe}`
+  return `${paint.dim(trunk)}${' '.repeat(Math.max(nameColumn - visibleLength(trunk), 0))}`
+}
+
+/** The task row below a folded lane's phase row, under the lane's name; none while the phase has no task on it. */
+const foldedTaskRow = (view: LaneView, indent: string, width: number): string[] => {
+  const phase = headPhase(view)
+  const { active: running, subagentTasks } = summaryOf(view)
+  const active = running.find((each) => each.phase.id === phase?.id)
+  const line = active && foldedTaskLine(active, subagentTasks, TEXTS.herd, indent, width)
+  return line ? [line] : []
+}
+
 const laneLines = (view: LaneView, open: boolean, width: number, columns: LaneColumns): string[] => {
   const { progress, status } = view
-  const cells = [
-    padVisible(paint.bold(fit(progress.lane.name, columns.name)), columns.name),
-    padVisible(agentLabel(status.agent), STATUS_WIDTH),
-  ].join(COLUMN_SEPARATOR)
+  const cells = padVisible(paint.bold(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)
-  return withDetail(
-    head,
-    laneDetail(view),
-    right,
-    width,
-    open ? `${UNDER_STATUS}${paint.dim(TREE.pipe)}` : CONTENT_INDENT,
-  )
+  const nameColumn = visibleLength(head) - visibleLength(cells)
+  const lines = withDetail(head, laneDetail(view, open), right, width, detailIndent(open, nameColumn))
+  return open ? lines : [...lines, ...foldedTaskRow(view, ' '.repeat(nameColumn), width)]
+}
+
+/** The parts of a session line: the session's title (the branch without one) at the left, the branch and the context value. */
+const sessionParts = (view: LaneView): { left: string; git: string; branch: string; context: string } => {
+  const git = gitLabel(view.status)
+  const branch = branchLabel(view.status)
+  return { left: view.sessionTitle ? plain(view.sessionTitle) : git, git, branch, context: contextValue(view.context) }
 }
 
 /**
- * The SESSION branch of an open lane: the session's title at the left; the branch at the end of the line, before the
+ * The session branch of an open lane: the session's title at the left; the branch at the end of the line, before the
  * context at the right. The title keeps its room: the branch gives way when both do not fit, and only then is the
  * title cut. Without a title the branch stands at the left.
  */
 const sessionLine = (view: LaneView, width: number): string => {
-  const git = gitLabel(view.status)
-  const context = contextValue(view.context)
+  const { left, git, branch, context } = sessionParts(view)
   if (!view.sessionTitle) return spread(fit(git, Math.max(width - CONTEXT_CELL_WIDTH, 1)), context, width)
-  const left = plain(view.sessionTitle)
   const room = width - (context ? CONTEXT_CELL_WIDTH : 0)
-  const withGit = visibleLength(left) + COLUMN_SEPARATOR.length + visibleLength(git) <= room
-  const right = [withGit ? git : '', context].filter(Boolean).join(COLUMN_SEPARATOR)
+  const fitting = [git, branch].find(
+    (label) => visibleLength(left) + COLUMN_SEPARATOR.length + visibleLength(label) <= room,
+  )
+  const right = [fitting ?? '', context].filter(Boolean).join(COLUMN_SEPARATOR)
   return spread(fit(left, Math.max(room, 1)), right, width)
 }
 
+/**
+ * The session line with the lane's one link chip on it, so the lane needs no row of chips: title, chip, branch and
+ * context. When the line is short the ahead and dirty counts of the branch go first, then the title is cut with `…`;
+ * without a title the branch stands at the left and the chip at the right. Null when even the cut title would be
+ * narrower than `MIN_TITLE_WIDTH`, and the chip keeps its row of chips.
+ */
+const sessionWithChip = (view: LaneView, chip: BadgeCell, width: number): Frame | null => {
+  const { left, git, branch, context } = sessionParts(view)
+  const tails = view.sessionTitle
+    ? [
+        [chip.cell, git, context],
+        [chip.cell, branch, context],
+      ]
+    : [[chip.cell, context]]
+  const candidates = tails.map((tail) => tail.filter(Boolean).join(COLUMN_SEPARATOR))
+  const roomFor = (candidate: string) => width - COLUMN_SEPARATOR.length - visibleLength(candidate)
+  const narrowest = candidates[candidates.length - 1] ?? ''
+  const cuts = Boolean(view.sessionTitle) && roomFor(narrowest) >= MIN_TITLE_WIDTH
+  const right = candidates.find((candidate) => visibleLength(left) <= roomFor(candidate)) ?? (cuts ? narrowest : null)
+  if (right === null) return null
+  const from = width - visibleLength(right)
+  const targets = chip.key === null ? [] : [{ line: 0, from, to: from + visibleLength(chip.cell), key: chip.key }]
+  return { lines: [spread(left, right, width)], cursorLine: -1, targets }
+}
+
+/** Session and link chips of an open lane: a lone chip on the session line when it fits there, else a row of chips. */
+const sessionAndChips = (
+  view: LaneView,
+  tickets: LaneTickets | null,
+  width: number,
+): { session: Frame; chips: Frame } => {
+  const cells = chipCells(laneChips(view), tickets, view.sentFiles)
+  const [lone] = cells
+  const inline = cells.length === 1 && lone ? sessionWithChip(view, lone, width) : null
+  if (inline) return { session: inline, chips: textFrame([]) }
+  return { session: textFrame([sessionLine(view, width)]), chips: packedFrame(cells, '', width) }
+}
+
 const underStatus = (frame: Frame): Frame =>
   prefixed(frame, { first: UNDER_STATUS, rest: UNDER_STATUS, style: (text) => text })
 
@@ -552,6 +749,16 @@ const underStatus = (frame: Frame): Frame =>
 const laneChips = ({ progress, chips }: LaneView): LinkChip[] =>
   progress.steps.flatMap(({ step }) => (step.planHref ? (chips[step.planHref] ?? []) : []))
 
+/** The lane's pull requests one under the other, each without the lane ticket its title starts with. */
+const pullRequestsFrame = (view: LaneView, context: LaneContext): Frame => {
+  const ids = (context.tickets?.shown ?? []).map(({ id }) => id)
+  return joinFrames(
+    view.pullRequests.map((pullRequest) =>
+      pullRequestFrame({ ...pullRequest, title: withoutTicketKey(pullRequest.title, ids) }, context),
+    ),
+  )
+}
+
 /** The lane line is a row of its own; an open lane continues with its pull requests and plans. */
 const laneBlock = (
   view: LaneView,
@@ -574,17 +781,13 @@ const laneBlock = (
   const row = rowFrame(laneKey(view.progress.lane.name), laneLines(view, open, width, columns), [], context)
   if (!open) return row
   const inner = deeper({ ...context, width: Math.max(width - UNDER_STATUS.length, 1) })
-  const head = {
-    session: (room: number) => sessionLine(view, room),
-    chips: (room: number) => chipFrame(laneChips(view), inner.tickets, room),
-  }
+  const head = { ...sessionAndChips(view, inner.tickets, inner.width), pullRequests: pullRequestsFrame(view, inner) }
   const [session, ...sections] = summaryChildren(inner, summaryOf(view), head)
   const alone = sections.every((section) => section.lines.length === 0)
   const sessionLead = alone ? { first: TREE.last, rest: TREE.gap } : { first: TREE.branch, rest: TREE.pipe }
   return joinFrames([
     row,
     underStatus(prefixed(session, { ...sessionLead, style: paint.dim })),
-    ...view.pullRequests.map((pullRequest) => pullRequestFrame(pullRequest, context)),
     underStatus(nest(sections)),
   ])
 }
@@ -647,9 +850,153 @@ const plannedRows = (planned: PlannedPlan[], width: number, indent: string): str
 
 const rule = (width: number): string => paint.dim(RULE.repeat(width))
 
-/** A dimmed rule before every lane block but the first, folded or open: it shows where one lane ends. */
-const separate = (blocks: Frame[], width: number): Frame[] =>
-  blocks.flatMap((frame, index) => (index === 0 ? [frame] : [textFrame([rule(width)]), frame]))
+/** The amber bar that starts every line of the for-you block: the one signal that this waits on the user. */
+const waitingBar = (): string => STATUS_PAINT[AGENT_STATUS.blocked](WAITING_MARK)
+
+/** The grey bar of the appointment block: it waits on nobody's answer. */
+const appointmentBar = (): string => paint.dim(WAITING_MARK)
+
+/**
+ * The head of an open block, `▾ <name> · <n> ──`, filled with the rule to the width, so it is the rule above the block.
+ * The label and the count wear the normal colour (the count in `countPaint`), only the rule is dim.
+ */
+const blockHead = (name: string, count: number, width: number, countPaint: (text: string) => string): string => {
+  const lead = `${chevronOf(true)} ${name} ${ITEM_SEPARATOR} `
+  const used = textWidth(`${lead}${count} `)
+  return `${lead}${countPaint(String(count))} ${paint.dim(RULE.repeat(Math.max(width - used, 0)))}`
+}
+
+const markedLine = (line: string, row: BlockRow, markPaint: (text: string) => string): string =>
+  line.startsWith(row.mark) ? `${markPaint(row.mark)}${line.slice(row.mark.length)}` : line
+
+/** The text from `from` on dimmed, without the blanks that pad it to the right edge. */
+const dimmedRest = (text: string, from: number): string => {
+  const end = text.trimEnd().length
+  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 `[ask]` button at the end of a
+ * question's first line wears the mark's paint.
+ */
+const blockRowLines = ({ bar, markPaint }: TopBlock, row: BlockRow): string[] =>
+  row.lines.map((line, index) => {
+    const withButton = index === 0 && row.askColumn !== null
+    const styled = dimmedRest(line, row.dimFrom[index] ?? line.length)
+    const marked = index === 0 ? markedLine(styled, row, markPaint) : styled
+    const text = withButton ? `${marked}${markPaint(ASK_BUTTON)}` : marked
+    return `${bar()} ${row.url ? link(row.url, text) : text}`
+  })
+
+/** A folded block: the one line `▸ <name> · <n>` and the first title as a preview; a click matches no row and no `+<n>` line. */
+const foldedBlockLines = ({ name, keys, rows }: TopBlock, width: number): BlockLines => {
+  const preview = rows[0]?.preview
+  const head = `${chevronOf(false)} ${name} ${ITEM_SEPARATOR} ${keys.length}`
+  return {
+    open: false,
+    lines: [paint.dim(fit(preview === undefined ? head : `${head}  ${preview}`, width))],
+    hit: { rows: [], moreKey: null, keys },
+  }
+}
+
+/**
+ * An open block on top of the herd: the head `▾ <name> · <n> ──`, one barred line per row (the first five, all while the
+ * block is expanded) and `▌ +<n>` for the rest, which turns into `▌ ▴ <n>` once all show and folds them again. A row wider than the pane is cut to
+ * one line; once expanded it wraps over several. The rule below is the stack's, not the block's.
+ */
+const openBlockLines = (block: TopBlock, width: number): BlockLines => {
+  const count = block.keys.length
+  const more = Math.max(count - SHOWN_BLOCK_ROWS, 0)
+  const moreLine = block.expanded ? `${LESS_MARK} ${more}` : `+${more}`
+  return {
+    open: true,
+    lines: [
+      blockHead(block.name, count, width, count > 0 ? block.countPaint : (text) => text),
+      ...block.rows.flatMap((row) => blockRowLines(block, row)),
+      ...(more > 0 ? [`${block.bar()} ${moreLine}`] : []),
+    ],
+    hit: { rows: block.rows, moreKey: moreKeyOf(count, block.moreKey), keys: block.keys },
+  }
+}
+
+const blockLinesOf = (block: TopBlock, state: Selection, id: TopBlockId, width: number): BlockLines =>
+  isBlockFolded(state, id, block.keys) ? foldedBlockLines(block, width) : openBlockLines(block, width)
+
+/**
+ * What waits on the user's answer, on top of the herd until it is closed: `▌ 📎 name` for a sent file or an
+ * Artifact, `▌ ? question` for a question of the board or of a session's dialog, in the amber of a lane that waits.
+ * One line while the user folded it.
+ */
+const waitingLines = (waiting: readonly WaitingItem[], state: Selection, width: number): BlockLines => {
+  const keys = waitingKeys(waiting)
+  const block: TopBlock = {
+    name: TEXTS.waitingHeading,
+    bar: waitingBar,
+    markPaint: STATUS_PAINT[AGENT_STATUS.blocked],
+    countPaint: STATUS_PAINT[AGENT_STATUS.blocked],
+    moreKey: WAITING_MORE_KEY,
+    expanded: state.expanded.has(WAITING_MORE_KEY),
+    keys,
+    rows: waitingRows(waiting, state.expanded, width),
+  }
+  return blockLinesOf(block, state, TOP_BLOCK.waiting, width)
+}
+
+/** The open appointments of the board under the for-you block: `▌ ◷ Mo 09:03 Release 2.0 rollout`, in a grey bar and with a grey mark. */
+const appointmentLines = ({ rows }: AppointmentBlock, state: Selection, width: number): BlockLines => {
+  const keys = appointmentKeys(rows)
+  const block: TopBlock = {
+    name: TEXTS.appointmentHeading,
+    bar: appointmentBar,
+    markPaint: paint.dim,
+    countPaint: (text) => text,
+    moreKey: APPOINTMENT_MORE_KEY,
+    expanded: state.expanded.has(APPOINTMENT_MORE_KEY),
+    keys,
+    rows: blockRows(appointmentItems(rows), state.expanded, width, APPOINTMENT_MORE_KEY),
+  }
+  return blockLinesOf(block, state, TOP_BLOCK.appointments, width)
+}
+
+const appointmentLinesOf = (
+  appointments: AppointmentBlock | undefined,
+  state: Selection,
+  width: number,
+): BlockLines | null =>
+  appointments && appointments.rows.length > 0 ? appointmentLines(appointments, state, width) : null
+
+/**
+ * The blocks one under the other, `offset` lines below the top of the screen, with one rule between neighbours: the
+ * head of an open block is that rule, a folded block gets a plain one above it unless a folded block stands right
+ * above (folded blocks share the rule below them), and a plain rule closes the stack. An
+ * absent block (null) takes no line and has no hit.
+ */
+const stackBlocks = (slots: readonly (BlockLines | null)[], offset: number, width: number): BlockStack => {
+  const lines: string[] = []
+  const hits: (BlockHit | null)[] = []
+  let previousFolded = false
+  for (const slot of slots) {
+    if (slot && !slot.open && !previousFolded) lines.push(rule(width))
+    hits.push(slot && { ...slot.hit, firstLine: offset + lines.length + 1 })
+    if (slot) {
+      lines.push(...slot.lines)
+      previousFolded = !slot.open
+    }
+  }
+  return { lines: lines.length > 0 ? [...lines, rule(width)] : lines, hits }
+}
+
+/**
+ * A dimmed rule before every section of the body but the first, which shows where one ends; none between two
+ * one-line lane blocks (the first `laneCount` sections), so folded lanes stand together as a list.
+ */
+const separate = (sections: Frame[], width: number, laneCount: number): Frame[] =>
+  sections.flatMap((frame, index) => {
+    if (index === 0) return [frame]
+    const listed = index < laneCount && frame.lines.length === 1 && sections[index - 1]?.lines.length === 1
+    return listed ? [frame] : [textFrame([rule(width)]), frame]
+  })
 
 /**
  * Why badges may be missing, said beside the clock: no watcher runs, or its state is stale. Nothing while it is live,
@@ -679,7 +1026,7 @@ const laneColumnsOf = (lanes: LaneView[], width: number): LaneColumns => {
   )
   const rightOf = (tallyWidth: number) =>
     Math.max(0, ...lanes.map((lane) => visibleLength(laneRight(lane, tallyWidth))))
-  const head = LANE_HEAD_CELLS + name + COLUMN_SEPARATOR.length + STATUS_WIDTH + COLUMN_SEPARATOR.length
+  const head = LANE_HEAD_CELLS + name + COLUMN_SEPARATOR.length
   const beside = MIN_BESIDE_WIDTH + COLUMN_SEPARATOR.length
   const phases = head + beside + (marks > 0 ? marks + COLUMN_SEPARATOR.length : 0) + rightOf(tally) <= width
   return { name, marks, right: rightOf(phases ? tally : 0), phases, tally }
@@ -698,11 +1045,11 @@ const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAge
 /**
  * Title and clock on top, the key hint at the bottom (with the legend after `?`), and in between one
  * block per lane: the lane line with its total bar, and for an open lane the phase rows. Folded lanes are
- * one line each and every lane block after the first is preceded by a dimmed rule. Lanes that wait and
+ * one line each, and a dimmed rule stands between lane blocks unless both are one line. Lanes that wait and
  * lanes with a worktree but no agent each share a closing block; finished lanes are not drawn.
  */
 export const renderScreen = (
-  { title, time, lanes, planned, watch, watchesTickets }: OverviewView,
+  { title, time, lanes, planned, watch, watchesTickets, awaiting = [], appointments, unplaced = [] }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
@@ -713,13 +1060,24 @@ export const renderScreen = (
   const blocks = active.map((lane) => laneBlock(lane, state, width, columns, badgeTexts))
   const notice = watchNotice({ lanes: active, watch, watchesTickets }, badgeTexts)
   const clock = notice ? `${paint.yellow(notice)}${COLUMN_SEPARATOR}${paint.dim(time)}` : paint.dim(time)
+  const titleLine = spread(`${HEADER_MARK} ${paint.bold(title)}`, clock, width)
+  const forYou = awaiting.length > 0 ? waitingLines(awaiting, state, width) : null
+  const dated = appointmentLinesOf(appointments, state, width)
+  const nowLines = unplaced.map((task) => nowLine(task, width))
+  const above = nowLines.length > 0 ? [titleLine, rule(width), ...nowLines] : [titleLine]
+  const stack = stackBlocks([forYou, dated], above.length, width)
+  const endsWithRule = stack.lines.length > 0 || nowLines.length === 0
+  const sections = [
+    ...blocks,
+    ...(parked.length > 0 ? [textFrame(parked)] : []),
+    ...(planned.length > 0 ? [plannedFrame(planned, state, width)] : []),
+  ]
+  const lead = !endsWithRule && blocks.length === 0 && sections.length > 0 ? [textFrame([rule(width)])] : []
   return {
-    header: [spread(`${HEADER_MARK} ${paint.bold(title)}`, clock, width), rule(width)],
-    body: joinFrames([
-      ...separate(blocks, width),
-      ...(parked.length > 0 ? [textFrame([rule(width), ...parked])] : []),
-      ...(planned.length > 0 ? [textFrame([rule(width)]), plannedFrame(planned, state, width)] : []),
-    ]),
+    waitingBlock: stack.hits[0],
+    appointmentBlock: stack.hits[1],
+    header: [...above, ...(stack.lines.length > 0 || nowLines.length > 0 ? stack.lines : [rule(width)])],
+    body: joinFrames([...lead, ...separate(sections, width, blocks.length)]),
     footer: [
       rule(width),
       fit(paint.dim(TEXTS.hint), width),