jackherd 1.8.1 → 1.10.0

package/src/plans/layout-phase.ts

@@ -1,14 +1,17 @@
 import type { ChecklistItem, DeferredItem, LaneProgress, PhaseProgress } from '../plan-format'
 import { onlyDocumentationOpen, phaseLabel } from '../plan-format'
-import { fit, padVisible, paint, wrap } from '../terminal/text'
+import { terminalSafe } from '../plan-format/terminal-text'
+import { fit, padVisible, paint, spread, wrap } from '../terminal/text'
 import { textWidth } from '../terminal/width'
 import type { WatchBadges } from '../watch/plan-badges'
+import type { ActiveTask, UnplannedTask } from './active-tasks'
 import { type Frame, rowFrame, textFrame } from './frame'
 import type { LaneTickets } from './lane-tickets'
 import type { LinkChip } from './link-chips'
 import type { PhaseModel } from './phase-models'
 import { itemKey, type Selection, tickedKey } from './selection'
 import { chevronOf, MODEL_MARK, PHASE_COUNT, PHASE_STATE, type PhaseState, phaseStateOf } from './symbols'
+import { taskBodyOf, taskNameOf } from './task-name'
 import { type BadgeTexts, TEXTS } from './texts'
 
 /** What every block of one lane is drawn with. */
@@ -26,13 +29,14 @@ export type LaneContext = {
 }
 
 export const ACTIVE_MARK = '▶'
+export const GUESSED_MARK = '▷'
 export const DEFERRED_MARK = '→'
 export const COLUMN_SEPARATOR = '  '
 export const MIN_TITLE_WIDTH = 8
 
 /** Places on each side of the slash of a count: `  9/9  `, ` 15/15 `, `123/456`. */
 const COUNT_PLACES = 3
-/** The cells before a count: `◐`, `✓`, `?`, `–` or nothing, padded so every slash on screen is in one column. */
+/** The cells before a count: `✓`, `?`, `–` or nothing, padded so every slash on screen is in one column. */
 const COUNT_MARK_WIDTH = 2
 const BLANK_COUNT = ' '.repeat(2 * COUNT_PLACES + 1)
 const COUNT_CELL_WIDTH = COUNT_MARK_WIDTH + 1 + BLANK_COUNT.length
@@ -54,6 +58,9 @@ const PHASE_MARK: Record<PhaseState, string> = {
 
 export const plain = (text: string): string => text.replace(MARKDOWN_MARKS, '')
 
+/** What a task reads as on one row: its short name where it carries one (`taskNameOf`), else its whole text. */
+export const taskTitle = (text: string): string => plain(taskNameOf(text) ?? text)
+
 export const countText = (done: number, total: number): string =>
   `${String(done).padStart(COUNT_PLACES)}/${String(total).padEnd(COUNT_PLACES)}`
 
@@ -87,25 +94,79 @@ export const modelMark = (model: PhaseModel | undefined): string =>
     : ''
 
 /** `text` wrapped beside a one-cell `mark`, each line in `style`; follow-up lines indent under the text. */
-const markedLines = (text: string, mark: string, style: (line: string) => string, width: number): string[] =>
-  wrap(plain(text), Math.max(width - 2, 1)).map((line, index) => `${index > 0 ? ' ' : mark} ${style(line)}`)
+const markedLines = (text: string, look: TaskLook, width: number): string[] => {
+  const lines = wrap(plain(text), Math.max(width - 2, 1))
+  return lines.map(
+    (line, index) =>
+      `${index > 0 ? ' ' : look.mark} ${look.style(line)}${index === lines.length - 1 ? look.suffix : ''}`,
+  )
+}
+
+/**
+ * The arrow of a phase or task being worked on: a teal `▶` where an agent reported it, a dim teal `▷` where the herd
+ * only guesses it from words. Yellow is the herd's colour for what waits on the user.
+ */
+export const activeArrow = (guessed: boolean): string =>
+  guessed ? paint.dim(paint.teal(GUESSED_MARK)) : paint.teal(ACTIVE_MARK)
+
+/** The title of a phase or task being worked on: bold where reported, plain where guessed. */
+export const activeTitle = (text: string, guessed: boolean): string => (guessed ? text : paint.bold(text))
+
+/** The agent's name after a title, dim; nothing while only one agent is active. */
+export const agentSuffix = (agent: string | null): string => (agent ? ` ${paint.dim(terminalSafe(agent))}` : '')
+
+/** The agent's name for the right edge of a row, dim; empty while only one agent is active. */
+export const agentCell = (agent: string | null): string => (agent ? paint.dim(terminalSafe(agent)) : '')
+
+/** Two cells: a task row hangs under its phase's label, which an arrow would otherwise push right. */
+export const TASK_INDENT = '  '
 
-/** The mark and the text style of a task: a ticked one green and dim, the one being worked on yellow and bold. */
-const taskLook = ({ done }: ChecklistItem, active: boolean): { mark: string; style: (line: string) => string } => {
-  if (active) return { mark: paint.yellow(ACTIVE_MARK), style: paint.bold }
-  return done ? { mark: paint.green('☑'), style: paint.dim } : { mark: '☐', style: (line) => line }
+/** `▶ <label> <text>`, the text bold, the agent dim at the right edge. */
+const labelledLine = (label: string, { text, agent }: UnplannedTask, width: number): string =>
+  spread(`${activeArrow(false)} ${label} ${paint.bold(plain(terminalSafe(text)))}`, agentCell(agent), width)
+
+/** `▶ now: <text>`: what an agent reports that no task of the plan names; the agent dim at the right edge. */
+export const nowLine = (task: UnplannedTask, width: number): string => labelledLine(TEXTS.now, task, width)
+
+/** `▶ Subagent: <description>`: a running subagent that names no phase and sits on none. */
+export const subagentLine = (description: string, width: number): string =>
+  labelledLine(TEXTS.subagent, { text: description, agent: null }, width)
+
+type TaskLook = { mark: string; style: (line: string) => string; suffix: string }
+
+/** The mark and the text style of a task: a ticked one green and dim, the one being worked on with its arrow. */
+const taskLook = ({ done }: ChecklistItem, active: ActiveTask | undefined): TaskLook => {
+  if (active) {
+    return {
+      mark: activeArrow(active.guessed),
+      style: (line) => activeTitle(line, active.guessed),
+      suffix: agentSuffix(active.agent),
+    }
+  }
+  return done
+    ? { mark: paint.green('☑'), style: paint.dim, suffix: '' }
+    : { mark: '☐', style: (line) => line, suffix: '' }
 }
 
-/** A closed task as one row, cut at the pane's edge with `…`. */
-const closedTaskRow = (item: ChecklistItem, active: boolean, width: number): string[] => {
+/** A closed task as one row, its short name or its text cut at the pane's edge with `…`. */
+const closedTaskRow = (item: ChecklistItem, active: ActiveTask | undefined, width: number): string[] => {
   const { mark, style } = taskLook(item, active)
-  return [fit(`${mark} ${style(plain(item.text))}`, width)]
+  return [spread(`${mark} ${style(taskTitle(item.text))}`, agentCell(active?.agent ?? null), width)]
 }
 
-/** An open task as rows: its whole text wrapped. */
-const openTaskRows = (item: ChecklistItem, active: boolean, width: number): string[] => {
-  const { mark, style } = taskLook(item, active)
-  return markedLines(item.text, mark, style, width)
+/** A named task opened: its name bold beside the mark, below it the line after the name (`taskBodyOf`) wrapped. */
+const namedTaskRows = (name: string, item: ChecklistItem, look: TaskLook, width: number): string[] => {
+  const body = wrap(plain(taskBodyOf(item.text)), Math.max(width - 2, 1)).map(
+    (line) => `  ${item.done ? paint.dim(line) : line}`,
+  )
+  return [fit(`${look.mark} ${paint.bold(plain(name))}${look.suffix}`, width), ...body]
+}
+
+/** An open task as rows: a named one by `namedTaskRows`, else its whole text wrapped. */
+const openTaskRows = (item: ChecklistItem, active: ActiveTask | undefined, width: number): string[] => {
+  const name = taskNameOf(item.text)
+  const look = taskLook(item, active)
+  return name ? namedTaskRows(name, item, look, width) : markedLines(item.text, look, width)
 }
 
 /** A task as a selectable row under its `key`: clickable across every line it takes, the cursor on its first. */
@@ -123,20 +184,20 @@ const tickedSummaryFrame = (count: number, phaseRowKey: string, width: number):
 })
 
 /**
- * The children of an open phase, one frame per task: open ones first, `active` marked among them, then the ones
+ * The children of an open phase, one frame per task: open ones first, the `active` ones (by task index) marked, then the ones
  * deferred to another phase, then the ticked ones listed or summed up.
  */
 export const phaseChildren = (
   context: LaneContext,
   phaseRowKey: string,
   phase: PhaseProgress,
-  active: ChecklistItem | null,
+  active: ReadonlyMap<number, ActiveTask>,
 ): Frame[] => {
   const { state, width } = context
   const frameOf = (item: ChecklistItem, index: number): Frame => {
     const key = itemKey(phaseRowKey, index)
-    const isActive = item === active
-    const rows = state.expanded.has(key) ? openTaskRows(item, isActive, width) : closedTaskRow(item, isActive, width)
+    const mark = active.get(index)
+    const rows = state.expanded.has(key) ? openTaskRows(item, mark, width) : closedTaskRow(item, mark, width)
     return taskFrame(key, rows, context)
   }
   const framesWhere = (done: boolean): Frame[] =>

package/src/plans/layout-summary.ts

@@ -1,49 +1,61 @@
-import { phaseLabel, phaseLabels } from '../plan-format'
-import { fit, padVisible, paint, spread, visibleLength } from '../terminal/text'
-import { textWidth } from '../terminal/width'
-import { deeper, type Frame, joinFrames, nest, prefixed, rowFrame, textFrame } from './frame'
-import type { ActivePhase, LaneSummary } from './lane-summary'
+import { phaseLabel } from '../plan-format'
+import { fit, paint, spread, visibleLength } from '../terminal/text'
+import { deeper, type Frame, joinFrames, nest, rowFrame, textFrame } from './frame'
+import type { ActivePhase, LaneSummary, PlacedPhase } from './lane-summary'
 import {
-  ACTIVE_MARK,
+  activeArrow,
+  activeTitle,
+  agentCell,
   COLUMN_SEPARATOR,
-  DEFERRED_MARK,
   type LaneContext,
   MIN_TITLE_WIDTH,
   modelMark,
+  nowLine,
   phaseChildren,
   phaseCountCell,
   plain,
+  subagentLine,
+  TASK_INDENT,
   taskFrame,
+  taskTitle,
 } from './layout-phase'
 import { type PhaseModel, phaseModelKey } from './phase-models'
-import { itemKey, phaseKey } from './selection'
+import { phaseRanges } from './phase-ranges'
+import { finishedKey, itemKey, nextKey, phaseKey } from './selection'
 import { PHASE_COUNT } from './symbols'
 import { type HerdTexts, TEXTS } from './texts'
 
-/** The context of a lane's sections: the lane's, with the herd's words. */
+/** The context of a lane's branches: the lane's, with the herd's words. */
 type SummaryContext = LaneContext & { labels: HerdTexts }
 
-/** The label column of the summary's sections, as wide as the widest label and two cells. */
-const sectionWidth = ({ sections }: HerdTexts): number =>
-  Math.max(...Object.values(sections).map(textWidth)) + COLUMN_SEPARATOR.length
-
-/** A frame behind a section label on its first line, its other lines indented to where the content starts. */
-const labelled = (labelWidth: number, label: string, frame: Frame): Frame =>
-  prefixed(frame, { first: padVisible(label, labelWidth), rest: ' '.repeat(labelWidth), style: paint.dim })
+/** Whether only the boxes of the review gate are open. */
+const onlyGateOpen = ({ items }: ActivePhase['phase']): boolean => {
+  const open = items.filter(({ done }) => !done)
+  return open.length > 0 && open.every(({ gate }) => gate)
+}
 
-/** `· 6 min ago`, dim: when the running phase last moved. */
-const ageCell = ({ minutesAgo }: ActivePhase, labels: HerdTexts): string =>
-  `${paint.dim(labels.minutesAgo(minutesAgo))}${COLUMN_SEPARATOR}`
+/**
+ * `· 6 min ago`, dim: when the running phase was last ticked or reported, nothing when the herd saw neither; `· gate`
+ * after it while only the review gate is open. Empty when there is neither.
+ */
+const ageCell = ({ minutesAgo, phase }: ActivePhase, labels: HerdTexts): string => {
+  const words = [
+    ...(minutesAgo === null ? [] : [labels.minutesAgo(minutesAgo)]),
+    ...(onlyGateOpen(phase) ? [labels.gate] : []),
+  ]
+  return words.length > 0 ? `${paint.dim(words.join(' '))}${COLUMN_SEPARATOR}` : ''
+}
 
 /**
- * `▶ P12 <title>   [model]  · 6 min ago   16/26`: title at the left, model, age and count at the right edge. In a pane
- * too narrow to leave the title `MIN_TITLE_WIDTH` cells, the model gives way first, then the age.
+ * `P12 <title>   [model]  · 6 min ago   16/26`: title at the left, model, age and count at the right edge, no arrow
+ * (arrows stand before tasks only). In a pane too narrow to leave the title `MIN_TITLE_WIDTH` cells, the model gives
+ * way first, then the age.
  */
 const activeRow = (active: ActivePhase, current: boolean, context: SummaryContext, model?: PhaseModel): string => {
   const { width, labels } = context
   const { phase } = active
   const title = phase.title === null ? paint.dim(TEXTS.notInPlan) : plain(phase.title)
-  const head = `${paint.yellow(ACTIVE_MARK)} ${phaseLabel(phase.id)} ${title}`
+  const head = `${phaseLabel(phase.id)} ${title}`
   const count = phaseCountCell(phase, current)
   const withAge = `${ageCell(active, labels)}${count}`
   const mark = modelMark(model)
@@ -52,17 +64,65 @@ const activeRow = (active: ActivePhase, current: boolean, context: SummaryContex
   return spread(head, candidates.find((right) => titleRoom(right) >= MIN_TITLE_WIDTH) ?? count, width)
 }
 
+/** What an active task reads as on one row: `Review gate` for a box of the review gate, else its short name or text. */
+const taskText = (item: ActivePhase['phase']['items'][number], labels: HerdTexts): string =>
+  item.gate ? labels.reviewGate : taskTitle(item.text)
+
+/** The texts of the tasks agents report on the phase, then the descriptions of the subagents that name no phase as `Subagent: …`. */
+const reportedTexts = (
+  { phase, tasks }: ActivePhase,
+  subagentTasks: readonly string[],
+  labels: HerdTexts,
+): string[] => [
+  ...tasks
+    .filter(({ guessed }) => !guessed)
+    .flatMap(({ index }) => {
+      const item = phase.items[index]
+      return item ? [taskText(item, labels)] : []
+    }),
+  ...subagentTasks.map((description) => `${TEXTS.subagent} ${taskTitle(description)}`),
+]
+
+/**
+ * `▶ Name +1` for a folded lane, behind `indent`: the first task the phase is on with the arrow of the open lane, `+n`
+ * for the others in parallel at the end; no ticks, the phase row shows them; the name cut to the pane's edge. A task
+ * an agent reports comes first, the descriptions of the `subagentTasks` after it. Null while neither exists: a task
+ * the herd only guesses from words is no sign that the lane works.
+ */
+export const foldedTaskLine = (
+  active: ActivePhase,
+  subagentTasks: readonly string[],
+  labels: HerdTexts,
+  indent: string,
+  width: number,
+): string | null => {
+  const [first, ...others] = reportedTexts(active, subagentTasks, labels)
+  if (first === undefined) return null
+  const lead = `${activeArrow(false)} `
+  const tail = others.length > 0 ? ` +${others.length}` : ''
+  const room = Math.max(width - visibleLength(indent) - visibleLength(lead) - visibleLength(tail), 1)
+  return `${indent}${lead}${activeTitle(fit(first, room), false)}${tail}`
+}
+
 /**
- * `→ <task>` under a closed running phase: the task it is on, dim, on one line whatever the task's fold, and a row a
- * click opens like the task itself; `→ review gate` in place of a box of the review gate; nothing when no task is open.
+ * One row per active task under a closed running phase, each with its own arrow: the title bold and the agent dim
+ * after it where agents reported it, `▷` and a plain title where the herd guesses. Always on one line whatever the
+ * task's fold, and a row a click opens like the task itself; `Review gate` in place of a box of the review gate.
  */
-const taskLineFrame = (context: SummaryContext, phaseRowKey: string, { phase, taskIndex }: ActivePhase): Frame => {
-  const item = taskIndex === null ? undefined : phase.items[taskIndex]
-  if (!item || taskIndex === null) return textFrame([])
-  const text = item.gate ? context.labels.reviewGate : plain(item.text)
-  const underTitle = ' '.repeat(visibleLength(ACTIVE_MARK) + 1)
-  const line = fit(`${underTitle}${paint.dim(`${DEFERRED_MARK} ${text}`)}`, context.width)
-  return taskFrame(itemKey(phaseRowKey, taskIndex), [line], context)
+const taskLinesFrame = (context: SummaryContext, phaseRowKey: string, { phase, tasks }: ActivePhase): Frame => {
+  return joinFrames(
+    tasks.flatMap((task) => {
+      const item = phase.items[task.index]
+      if (!item) return []
+      const text = taskText(item, context.labels)
+      const line = spread(
+        `${TASK_INDENT}${activeArrow(task.guessed)} ${activeTitle(text, task.guessed)}`,
+        agentCell(task.agent),
+        context.width,
+      )
+      return [taskFrame(itemKey(phaseRowKey, task.index), [line], context)]
+    }),
+  )
 }
 
 /** A running phase as a row that opens to its tasks; closed, the task it is on below it. */
@@ -71,70 +131,99 @@ const activeFrame = (context: SummaryContext, active: ActivePhase): Frame => {
   const stepIndex = active.stepIndex ?? -1
   const key = phaseKey(progress.lane.name, stepIndex, active.phase.id)
   const current = progress.current?.stepIndex === stepIndex && progress.current.phaseId === active.phase.id
-  const item = active.taskIndex === null ? null : (active.phase.items[active.taskIndex] ?? null)
   const model = context.models[phaseModelKey(stepIndex, active.phase.id)]
   const row = rowFrame(key, [activeRow(active, current, context, model)], [], context)
-  if (!state.expanded.has(key)) return joinFrames([row, taskLineFrame(context, key, active)])
-  return joinFrames([row, nest(phaseChildren(deeper(context), key, active.phase, item))])
+  if (!state.expanded.has(key)) return joinFrames([row, taskLinesFrame(context, key, active)])
+  return joinFrames([
+    row,
+    nest(phaseChildren(deeper(context), key, active.phase, new Map(active.tasks.map((task) => [task.index, task])))),
+  ])
 }
 
-/** `wave 2: P5 · P10` or, without waves, `P7`. */
-const nextText = ({ next }: LaneSummary, labels: HerdTexts): string =>
-  next ? `${next.wave === null ? '' : `${labels.wave(next.wave)} `}${phaseLabels(next.phaseIds, ' · ')}` : ''
-
 /** `P8 ?` for a named phase the plan lacks, `P9 –` for one without a checkbox. */
 const unwrittenText = ({ id, missing }: LaneSummary['unwritten'][number]): string =>
   `${phaseLabel(id)} ${paint.dim(missing ? PHASE_COUNT.missing : PHASE_COUNT.empty)}`
 
-/** `P6 P7 P8 ? · Second plan: P1`: the current plan's waiting phases, then the other plans' by their name. */
-const laterText = ({ later, unwritten }: LaneSummary): string => {
-  const own = [
-    ...(later[0]?.planTitle === null ? [phaseLabels(later[0].phaseIds, ' ')] : []),
-    ...unwritten.map(unwrittenText),
-  ]
-  const others = later
+/**
+ * `next P5–P7, P10 P8 ? · Second plan: P1` on one line: every open phase that does not run, the current plan's as
+ * ranges, then the other plans' by their name; empty when none waits.
+ */
+const nextLineText = (summary: LaneSummary, labels: HerdTexts): string => {
+  const ownIds = summary.waiting.filter(({ planTitle }) => planTitle === null).flatMap(({ phaseIds }) => phaseIds)
+  const ownRanges = phaseRanges(ownIds)
+  const own = [...(ownRanges ? [ownRanges] : []), ...summary.unwritten.map(unwrittenText)]
+  const others = summary.waiting
     .filter(({ planTitle }) => planTitle !== null)
-    .map(({ planTitle, phaseIds }) => `${plain((planTitle ?? '').split(':')[0]).trim()}: ${phaseLabels(phaseIds, ' ')}`)
-  return [...(own.length > 0 ? [own.join(' ')] : []), ...others].join(' · ')
+    .map(({ planTitle, phaseIds }) => `${plain((planTitle ?? '').split(':')[0]).trim()}: ${phaseRanges(phaseIds)}`)
+  const text = [...(own.length > 0 ? [own.join(' ')] : []), ...others].join(' · ')
+  return text ? `${paint.dim(labels.next)} ${text}` : ''
 }
 
-/** ` · not merged` once for the line when every finished phase waits for its merge, ` · P1 P2 not merged` when some do. */
-const unmergedNote = ({ finished }: LaneSummary, labels: HerdTexts): string => {
-  const unmerged = finished.filter(({ unmerged }) => unmerged).map(({ id }) => id)
-  if (unmerged.length === 0) return ''
-  const which = unmerged.length === finished.length ? '' : `${phaseLabels(unmerged, ' ')} `
-  return ` · ${paint.yellow(`${which}${labels.notMerged}`)}`
+/** `done P1–P7, P10` on one line: the word `done` in green, the finished phases as ranges. */
+const finishedText = (summary: LaneSummary, labels: HerdTexts): string => {
+  const phases = phaseRanges(summary.finished.map(({ id }) => id))
+  return phases ? `${paint.green(labels.done)} ${phases}` : ''
 }
 
-/** `✓ P1 ✓ P4 · not merged` on one line. */
-const finishedText = (summary: LaneSummary, labels: HerdTexts): string => {
-  const phases = summary.finished.map(({ id }) => `${paint.green(PHASE_COUNT.allTicked)} ${phaseLabel(id)}`).join(' ')
-  return phases ? `${phases}${unmergedNote(summary, labels)}` : ''
+/** A phase that does not run as a row, which opens to its tasks like a running one; closed, it has no task line below it. */
+const restingFrame = (context: SummaryContext, { phase, stepIndex }: PlacedPhase): Frame =>
+  activeFrame(context, { phase, stepIndex, minutesAgo: null, tasks: [] })
+
+/**
+ * One line of text cut at the pane's edge, a row under `key`; no line when the text is empty. Open, it continues with
+ * a row per phase it names and the `unwritten` lines, each phase opening to its tasks.
+ */
+const foldFrame = (
+  context: SummaryContext,
+  key: string,
+  text: string,
+  { phases, unwritten }: { phases: readonly PlacedPhase[]; unwritten: string[] },
+): Frame => {
+  if (!text) return textFrame([])
+  const row = rowFrame(key, [fit(text, context.width)], [], context)
+  if (!context.state.expanded.has(key)) return row
+  const inner = deeper(context)
+  const children = [
+    ...phases.map((placed) => restingFrame(inner, placed)),
+    ...unwritten.map((line) => textFrame([fit(line, inner.width)])),
+  ]
+  return joinFrames([row, nest(children)])
 }
 
-/** A section with one line of text, cut at the pane's edge; no frame when the text is empty. */
-const textSection = (labelWidth: number, label: string, text: string, width: number): Frame =>
-  text ? labelled(labelWidth, label, textFrame([fit(text, Math.max(width - labelWidth, 1))])) : textFrame([])
+/** What an open lane shows above its phases, drawn at the width of its branches: the session, its pull requests and its link chips. */
+export type LaneHead = { session: Frame; pullRequests: Frame; chips: Frame }
 
-/** What an open lane shows above its sections, each drawn at the width its label column leaves. */
-export type LaneHead = { session: (width: number) => string; chips: (width: number) => Frame }
+/** The `next` and `done` rows of an open lane. */
+const restingFrames = (context: SummaryContext, summary: LaneSummary): Frame[] => {
+  const laneName = context.progress.lane.name
+  return [
+    foldFrame(context, nextKey(laneName), nextLineText(summary, context.labels), {
+      phases: summary.waitingPhases,
+      unwritten: summary.unwritten.map(unwrittenText),
+    }),
+    foldFrame(context, finishedKey(laneName), finishedText(summary, context.labels), {
+      phases: summary.finishedPhases,
+      unwritten: [],
+    }),
+  ]
+}
 
 /**
- * The children of an open lane, each on a branch with its label in one column: SESSION, the 📎 chips, then NOW, NEXT,
- * LATER and DONE, each section only when it has phases.
+ * The children of an open lane, one branch each, told apart by their marks rather than by a label: the session
+ * (`⎇`), the pull requests (`↗`), the link chips, then one branch per running phase (its tasks `▶`/`▷` under it), the
+ * `now:` and `Subagent:` lines, `next` with the open phases that wait, and `done` with the finished ones; a branch without lines is left out.
  */
 export const summaryChildren = (context: LaneContext, summary: LaneSummary, head: LaneHead): Frame[] => {
   const labels = TEXTS.herd
-  const labelWidth = sectionWidth(labels)
-  const inner = { ...context, width: Math.max(context.width - labelWidth, 1), labels }
-  const { sections } = labels
-  const now = summary.active.map((active) => activeFrame(inner, active))
+  const inner = { ...context, labels }
+  const { width } = context
   return [
-    labelled(labelWidth, sections.session, textFrame([head.session(inner.width)])),
-    labelled(labelWidth, sections.chips, head.chips(inner.width)),
-    ...(now.length > 0 ? [labelled(labelWidth, sections.now, joinFrames(now))] : []),
-    textSection(labelWidth, sections.next, nextText(summary, labels), context.width),
-    textSection(labelWidth, sections.later, laterText(summary), context.width),
-    textSection(labelWidth, sections.done, finishedText(summary, labels), context.width),
+    head.session,
+    head.pullRequests,
+    head.chips,
+    ...summary.active.map((active) => activeFrame(inner, active)),
+    ...summary.unplanned.map((task) => textFrame([nowLine(task, width)])),
+    ...summary.subagentTasks.map((description) => textFrame([subagentLine(description, width)])),
+    ...restingFrames(inner, summary),
   ]
 }