jackherd 1.9.0 → 1.10.0

package/src/plans/layout.ts

@@ -28,6 +28,7 @@ import {
   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'
@@ -41,25 +42,40 @@ import {
   nowLine,
   plain,
 } from './layout-phase'
-import { summaryChildren } from './layout-summary'
+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, 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, 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 { SHOWN_WAITING, WAITING_MARK, type WaitingRow, waitingRows } from './waiting-click'
+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;
@@ -105,13 +121,24 @@ export type OverviewView = {
   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. */
-/** The drawn screen; `waitingLine` is the screen line (0-based) of the first for-you row, where a click is matched. */
-export type Screen = { header: string[]; body: Frame; footer: string[]; waitingLine: number }
+/**
+ * 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
@@ -121,8 +148,32 @@ export type Screen = { header: string[]; body: Frame; footer: string[]; waitingL
  */
 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 WOOF = 'woof'
 const SENT_MARK = '📎'
 const SYMBOL_WIDTH = 2
 const NAME_WIDTH_MAX = 24
@@ -140,7 +191,7 @@ 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 = '  '
@@ -189,12 +240,11 @@ const aheadLabel = ({ branch, ahead }: LaneStatus): string => {
   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(' ')
 
@@ -247,7 +297,7 @@ const checksColumnOf = (pullRequest: PullRequest): number =>
 /**
  * `⟦↗ #<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 = numberCell(pullRequest)
@@ -474,7 +524,7 @@ const chipCells = (chips: LinkChip[], tickets: LaneTickets | null, sent: readonl
 
 /**
  * `🌐 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,
@@ -494,15 +544,17 @@ const badgeCells = (
 }
 
 /**
- * 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 the `✓` line 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)}` : ''}` : ''
@@ -590,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)
@@ -602,7 +654,7 @@ const markedRight = (view: LaneView, columns: LaneColumns): string => {
 
 /**
  * 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 (17:40), as the branches of an open lane do; an open lane keeps its trunk in front.
+ * 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)
@@ -610,19 +662,30 @@ const detailIndent = (open: boolean, nameColumn: number): string => {
   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)
   const head = `${paint.dim(chevronOf(open))} ${symbolCell(status.agent)} ${cells}`
   const right = open ? laneProgressColumn(view, tallyWidthOf(columns)) : markedRight(view, columns)
   const nameColumn = visibleLength(head) - visibleLength(cells)
-  return withDetail(head, laneDetail(view, open), right, width, detailIndent(open, nameColumn))
+  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; context: string } => {
+const sessionParts = (view: LaneView): { left: string; git: string; branch: string; context: string } => {
   const git = gitLabel(view.status)
-  return { left: view.sessionTitle ? plain(view.sessionTitle) : git, git, context: contextValue(view.context) }
+  const branch = branchLabel(view.status)
+  return { left: view.sessionTitle ? plain(view.sessionTitle) : git, git, branch, context: contextValue(view.context) }
 }
 
 /**
@@ -631,31 +694,36 @@ const sessionParts = (view: LaneView): { left: string; git: string; context: str
  * title cut. Without a title the branch stands at the left.
  */
 const sessionLine = (view: LaneView, width: number): string => {
-  const { left, git, context } = sessionParts(view)
+  const { left, git, branch, context } = sessionParts(view)
   if (!view.sessionTitle) return spread(fit(git, Math.max(width - CONTEXT_CELL_WIDTH, 1)), context, width)
   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, the branch giving way first; without a title the branch at the left and the chip at the right. Null when
- * the line has no room for the chip beside the whole title, and the chip keeps its row of chips.
+ * 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, context } = sessionParts(view)
+  const { left, git, branch, context } = sessionParts(view)
   const tails = view.sessionTitle
     ? [
         [chip.cell, git, context],
-        [chip.cell, context],
+        [chip.cell, branch, context],
       ]
     : [[chip.cell, context]]
-  const right = tails
-    .map((tail) => tail.filter(Boolean).join(COLUMN_SEPARATOR))
-    .find((candidate) => visibleLength(left) + COLUMN_SEPARATOR.length + visibleLength(candidate) <= width)
-  if (right === undefined) return null
+  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 }
@@ -782,32 +850,153 @@ const plannedRows = (planned: PlannedPlan[], width: number, indent: string): str
 
 const rule = (width: number): string => paint.dim(RULE.repeat(width))
 
-/** The rule under the for-you block, labelled woof (Jack barks) so the block reads as a section of its own. */
-const barkingRule = (width: number): string => {
-  const lead = `${RULE.repeat(2)} ${WOOF} `
-  return paint.dim(`${lead}${RULE.repeat(Math.max(width - textWidth(lead), 0))}`)
+/** 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)))}`
 }
 
-/** One row as lines: a dim bar and the text in bold on each, linked when the row has an address. */
-const waitingRowLines = ({ lines, url }: WaitingRow): string[] =>
-  lines.map((line) => `${paint.dim(WAITING_MARK)} ${paint.bold(url ? link(url, line) : line)}`)
+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)}`
+}
 
 /**
- * What waits on the user's answer, on top of the herd until it is closed: `▌ 📎 name` for a sent file or an Artifact
- * and `▌ ? question` for a question of the board, up to five and `▌ +<n>` for the rest. A row wider than the pane is
- * cut to one line; once expanded it wraps over several.
+ * 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 waitingLines = (waiting: readonly WaitingItem[], expanded: ReadonlySet<string>, width: number): string[] => {
-  const more = Math.max(waiting.length - SHOWN_WAITING, 0)
-  return [
-    ...waitingRows(waiting, expanded, width).flatMap(waitingRowLines),
-    ...(more > 0 ? [`${paint.dim(WAITING_MARK)} +${more}`] : []),
-  ]
+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 },
+  }
 }
 
-/** 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]))
+/**
+ * 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,
@@ -856,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, awaiting = [], unplaced = [] }: OverviewView,
+  { title, time, lanes, planned, watch, watchesTickets, awaiting = [], appointments, unplaced = [] }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
@@ -871,19 +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 top = [spread(`${HEADER_MARK} ${paint.bold(title)}`, clock, width), rule(width)]
+  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 {
-    waitingLine: top.length + unplaced.length,
-    header: [
-      ...top,
-      ...unplaced.map((task) => nowLine(task, width)),
-      ...(awaiting.length > 0 ? [...waitingLines(awaiting, state.expanded, width), barkingRule(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),

package/src/plans/link-chips.ts

@@ -14,6 +14,7 @@ const MARKS = /\*\*|`/g
 const CONTROL = /\p{Cc}/gu
 
 const linksOf = (line: string): Found[] => {
+  if (!line.includes('http')) return []
   const found: Found[] = []
   const take = (url: string, text: string | null, index: number) =>
     found.push({ url, text, before: line.slice(0, index), line })