jackherd 1.8.0 → 1.9.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,16 +27,25 @@ import {
   type WatchBadges,
   type WatchHealth,
 } from '../watch/plan-badges'
+import type { UnplannedTask } from './active-tasks'
 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 { type LaneTickets, withoutTicketKey } from './lane-tickets'
+import {
+  COLUMN_SEPARATOR,
+  countCell,
+  countText,
+  type LaneContext,
+  MIN_TITLE_WIDTH,
+  nowLine,
+  plain,
+} from './layout-phase'
 import { 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,
   isLaneOpen,
@@ -45,9 +55,11 @@ import {
   selectedKey,
   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, 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'
 
 /**
  * Where a lane stands outside its plan. `agent` is the terminal adapter's status, null when no agent is listed;
@@ -78,6 +90,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 +103,15 @@ 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[]
+  /** 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; `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 }
 
 /**
  * Widths shared by every lane line: the name column, the folded pull request badges, and bar with context. They are
@@ -103,6 +122,8 @@ export type Screen = { header: string[]; body: Frame; footer: string[] }
 type LaneColumns = { name: number; marks: number; right: number; phases: boolean; tally: number }
 
 const BRANCH_MARK = '⎇'
+const WOOF = 'woof'
+const SENT_MARK = '📎'
 const SYMBOL_WIDTH = 2
 const NAME_WIDTH_MAX = 24
 const NON_BREAKING_SPACE = '\u00a0'
@@ -114,7 +135,6 @@ 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. */
@@ -127,17 +147,14 @@ 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 +171,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,7 +186,7 @@ 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 gitLabel = (status: LaneStatus): string =>
@@ -229,18 +236,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).
  */
 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 +263,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 +276,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 +356,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,18 +452,24 @@ 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)
 }
 
 /**
@@ -412,12 +493,9 @@ 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.
+ * ticked to the end, whose state the `✓` line says (`not merged`). Null when there is neither.
  */
 const headPhase = (view: LaneView): PhaseProgress | null => {
   const current = currentPhase(view.progress)
@@ -457,17 +535,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 +573,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) : ''
@@ -512,39 +600,80 @@ 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 (17:40), 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))}`
+}
+
 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)
+  return withDetail(head, laneDetail(view, open), right, width, detailIndent(open, nameColumn))
+}
+
+/** 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 git = gitLabel(view.status)
+  return { left: view.sessionTitle ? plain(view.sessionTitle) : git, git, 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, 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)
   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.
+ */
+const sessionWithChip = (view: LaneView, chip: BadgeCell, width: number): Frame | null => {
+  const { left, git, context } = sessionParts(view)
+  const tails = view.sessionTitle
+    ? [
+        [chip.cell, git, context],
+        [chip.cell, 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 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 +681,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 +713,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,6 +782,29 @@ 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))}`)
+}
+
+/** 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)}`)
+
+/**
+ * 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.
+ */
+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}`] : []),
+  ]
+}
+
 /** 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]))
@@ -679,7 +837,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 }
@@ -702,7 +860,7 @@ const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAge
  * 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 = [], unplaced = [] }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
@@ -713,8 +871,14 @@ 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)]
   return {
-    header: [spread(`${HEADER_MARK} ${paint.bold(title)}`, clock, width), rule(width)],
+    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])] : []),

package/src/plans/live.ts

@@ -25,9 +25,11 @@ import {
   inputOutcome,
   isSprintPageKey,
   overviewSelection,
+  parseMouse,
   splitKeys,
   syncLaneFolds,
   targetKeys,
+  toggledExpansion,
   type View,
   windowTop,
 } from './selection'
@@ -37,6 +39,7 @@ import { loadSnapshot, type Snapshot, type Source } from './snapshot'
 import { exportSprintPage, writeSprintPageInSteps } from './sprint-export'
 import { boardTexts } from './texts'
 import { bodyRows, clockOf, draw, paneWidth, renderSnapshot, startSelection, TERMINAL_OFF, TERMINAL_ON } from './view'
+import { waitingClick, waitingRows } from './waiting-click'
 
 /** The state of the running view; only the functions below `runLive` change it. */
 type Live = {
@@ -243,6 +246,21 @@ const openPlan = (live: Live, snapshot: Snapshot, address: string) => {
   live.notice = reason === null ? texts.pageOpened(live.page.path) : texts.pageNotOpenedReason(reason)
 }
 
+/** A plain click on the for-you block expands or folds a cut-off row, or opens its file or Artifact; the opener's failure shows in the footer. */
+const clickWaiting = (live: Live, snapshot: Snapshot, screen: Screen, input: string): boolean => {
+  const mouse = parseMouse(input)
+  const rows = waitingRows(snapshot.waiting ?? [], live.view.selection.expanded, paneWidth())
+  const outcome = mouse ? waitingClick(rows, screen.waitingLine, mouse) : null
+  if (!outcome) return false
+  if ('toggle' in outcome) {
+    live.view = { ...live.view, selection: toggledExpansion(live.view.selection, outcome.toggle) }
+    return true
+  }
+  const reason = openInBrowser(outcome.open)
+  if (reason) live.notice = boardTextsOf(live).notOpened(terminalSafe(reason))
+  return true
+}
+
 const handleInput = (live: Live, input: string) => {
   const { snapshot, screen } = live
   if (!snapshot || !screen) return
@@ -251,6 +269,10 @@ const handleInput = (live: Live, input: string) => {
     void writeSprintPage(live, snapshot)
     return
   }
+  if (clickWaiting(live, snapshot, screen, input)) {
+    redraw(live)
+    return
+  }
   const context = {
     keys: targetKeys(screen.body.targets),
     targets: screen.body.targets,

package/src/plans/phase-models.ts

@@ -1,5 +1,5 @@
 import { type LaneProgress, resolvePlanPath } from '../plan-format'
-import { isRecord } from '../watch/json-guards'
+import { isRecord } from '../shared/is-record'
 
 /** The model families a phase ran on and was recommended, as lower-case words; `fits` null without a recommendation. */
 export type PhaseModel = { used: string; recommended: string | null; fits: boolean | null }