jackherd 1.7.0 → 1.8.0

package/src/plans/layout.ts

@@ -1,27 +1,23 @@
 import { CONTEXT_LEVEL, type ContextLevel, type ContextReading, contextLabel } from '../context'
-import type { ChecklistItem, DeferredItem, LaneProgress, PhaseProgress, StepProgress } from '../plan-format'
-import { activeItem, currentPhase, isTickedUnmerged, onlyDocumentationOpen, PHASE_ID_PREFIX } from '../plan-format'
+import type { LaneProgress, PhaseProgress } from '../plan-format'
+import { currentPhase, isPhaseOpen, phaseLabel } from '../plan-format'
 import {
   BADGE_TONE,
-  BAR_SEGMENT,
   type BadgeTone,
   badge,
   bar,
   box,
   fit,
-  INVERSE_ON,
   packGroups,
   padVisible,
   paint,
-  RESET,
   spread,
-  stripAnsi,
   visibleLength,
   wrap,
 } from '../terminal/text'
 import { AGENT_STATUS, type AgentStatus, isAgentStatus } from '../terminal/types'
 import { textWidth } from '../terminal/width'
-import { PLAN_LANGUAGE, type PlanLanguage } from '../vocabulary'
+import { PLAN_LANGUAGE } from '../vocabulary'
 import {
   NO_BADGES,
   type PullRequestBadges,
@@ -30,38 +26,27 @@ import {
   type WatchBadges,
   type WatchHealth,
 } from '../watch/plan-badges'
+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 { chipKey, type LinkChip, planUrlOf } from './link-chips'
-import { type PhaseModel, phaseModelKey } from './phase-models'
+import type { PhaseModel } from './phase-models'
 import { type PlannedPlan, phaseList, plannedPhaseCount } from './planned'
 import { CHECKS, type ChecksState, type PullRequest, pullRequestKey } from './pull-requests'
 import {
   type ClickTarget,
-  followingKey,
   isLaneOpen,
-  itemKey,
   laneKey,
   PLANNED_KEY,
-  phaseKey,
   type Selection,
   selectedKey,
   targetKeys,
-  tickedKey,
 } from './selection'
 import { shownWithMore } from './shown-with-more'
-import {
-  chevronOf,
-  MODEL_MARK,
-  NO_AGENT_SYMBOL,
-  NO_AGENT_WORD,
-  PHASE_COUNT,
-  PHASE_STATE,
-  type PhaseState,
-  phaseStateOf,
-  statusSymbol,
-  statusWord,
-} from './symbols'
+import { chevronOf, NO_AGENT_SYMBOL, NO_AGENT_WORD, statusSymbol, statusWord } from './symbols'
 import { BADGE_TEXTS, type BadgeTexts, checksText, laneMarkText, TEXTS } from './texts'
 
 /**
@@ -81,8 +66,10 @@ export type LaneView = {
   chips: Record<string, LinkChip[]>
   /** How full the agent's context is; null when the terminal gave no session or the session has no log. */
   context?: ContextReading | null
-  /** The open phases of the lane's plans that its steps do not name; drawn as a folded row under the phases. */
-  following?: PlannedPlan[]
+  /** What the lane works on now, what comes next and after, and what is finished; derived from `progress` when absent. */
+  summary?: LaneSummary
+  /** The title of the agent's session as the terminal shows it; absent when it has none. */
+  sessionTitle?: string
   /** A running lane the sprint table has no row for; drawn with the mark `no row in lanes`. */
   unlisted?: boolean
   /** Preview and feedback of the lane's pull requests from the running watcher's state; none without a watcher. */
@@ -93,10 +80,7 @@ export type LaneView = {
   models?: Record<string, PhaseModel>
 }
 
-/**
- * `watch` is the health of the watcher the badges come from, absent when it was not read; `language` the project's
- * response language for the badges' words, English when absent.
- */
+/** `watch` is the health of the watcher the badges come from, absent when it was not read. */
 export type OverviewView = {
   title: string
   time: string
@@ -105,78 +89,45 @@ 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
-  language?: PlanLanguage
 }
 
-/**
- * The lines of a frame, the line holding the selected row, a phase or a task (-1 when none), so the window can
- * follow it, and the spans a click expands or closes.
- */
-export type Frame = { lines: string[]; cursorLine: number; targets: ClickTarget[] }
-
 /** 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[] }
 
-/** What every block of one lane is drawn with. */
-type LaneContext = {
-  progress: LaneProgress
-  state: Selection
-  width: number
-  chips: Record<string, LinkChip[]>
-  badges: WatchBadges
-  badgeTexts: BadgeTexts
-  /** The lane's tickets for the plan block that shows them, the first; null in every other block. */
-  tickets: LaneTickets | null
-  /** The model each phase ran on, by `phaseModelKey`. */
-  models: Record<string, PhaseModel>
-}
-
 /**
  * Widths shared by every lane line: the name column, the folded pull request badges, and bar with context. They are
  * measured over every lane on screen, open ones too, so opening or closing a lane moves no other lane's columns.
+ * `phases` says whether the phase count follows the bar: it gives way on every line when it would push a lane's
+ * detail onto a line of its own or cut its status.
  */
-type LaneColumns = { name: number; marks: number; right: number }
-
-type StepContext = LaneContext & { stepIndex: number }
-
-type PhaseEntry = { stepIndex: number; phase: PhaseProgress }
+type LaneColumns = { name: number; marks: number; right: number; phases: boolean; tally: number }
 
 const BRANCH_MARK = '⎇'
-const ACTIVE_MARK = '▶'
-const DEFERRED_MARK = '→'
 const SYMBOL_WIDTH = 2
-const COLUMN_SEPARATOR = '  '
 const NAME_WIDTH_MAX = 24
 const NON_BREAKING_SPACE = '\u00a0'
 const ITEM_SEPARATOR = '·'
 const RULE = '─'
 const CONTENT_INDENT = '   '
-
-/** The tree lines: a branch to a sibling that has more below it, the last branch, and what carries on beside them. */
-const TREE = { branch: '├─ ', last: '└─ ', pipe: '│  ', gap: '   ', trunk: '│' } as const
-const TREE_GUTTER = TREE.branch.length
-
-/** 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. */
-const COUNT_MARK_WIDTH = 2
-const BLANK_COUNT = ' '.repeat(2 * COUNT_PLACES + 1)
-const MIN_TITLE_WIDTH = 8
 const MIN_BESIDE_WIDTH = 24
 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). */
-const PULL_REQUEST_INDENT = '  '
+/**
+ * Under the lane line's status symbol: where the pull request row and its badge line start (D96), 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 = '     '
-const MARKDOWN_MARKS = /\*\*|`/g
 
 /** Lower ranks need the coordinator sooner; a status an adapter adds later ranks after `working`. */
 const URGENCY: Record<AgentStatus, number> = {
@@ -212,48 +163,6 @@ const urgencyOf = ({ status }: LaneView): number => {
 export const sortByUrgency = (lanes: readonly LaneView[]): LaneView[] =>
   [...lanes].sort((left, right) => urgencyOf(left) - urgencyOf(right))
 
-const plain = (text: string): string => text.replace(MARKDOWN_MARKS, '')
-
-const isCurrent = (progress: LaneProgress, stepIndex: number, phase: PhaseProgress): boolean =>
-  progress.current?.stepIndex === stepIndex && progress.current.phaseId === phase.id
-
-const PHASE_PAINT: Record<PhaseState, (count: string) => string> = {
-  [PHASE_STATE.missing]: paint.dim,
-  [PHASE_STATE.empty]: paint.dim,
-  [PHASE_STATE.all]: paint.green,
-  [PHASE_STATE.open]: (count) => count,
-}
-
-const countText = (done: number, total: number): string =>
-  `${String(done).padStart(COUNT_PLACES)}/${String(total).padEnd(COUNT_PLACES)}`
-
-const COUNT_CELL_WIDTH = COUNT_MARK_WIDTH + 1 + BLANK_COUNT.length
-
-/** Mark and count in one fixed-width cell at the right edge, the same for the lane, phase and planned rows. */
-const countCell = (mark: string, count: string): string => `${padVisible(mark, COUNT_MARK_WIDTH)} ${count}`
-
-/** A word in place of a count, right-aligned in the width of the count cell like `n/m`. */
-const wordCell = (word: string): string => `${' '.repeat(Math.max(COUNT_CELL_WIDTH - textWidth(word), 0))}${word}`
-
-const PHASE_MARK: Record<PhaseState, string> = {
-  [PHASE_STATE.missing]: PHASE_COUNT.missing,
-  [PHASE_STATE.empty]: PHASE_COUNT.empty,
-  [PHASE_STATE.all]: '',
-  [PHASE_STATE.open]: '',
-}
-
-/** The count cell of a phase row at the right edge; the current phase is bold yellow. A phase lacking only the documentation box says so instead of a count. */
-const phaseCountCell = (phase: PhaseProgress, current: boolean): string => {
-  const state = phaseStateOf(phase)
-  if (state === PHASE_STATE.open && onlyDocumentationOpen(phase)) {
-    const cell = wordCell(TEXTS.allButDocs)
-    return current ? paint.bold(paint.yellow(cell)) : paint.green(cell)
-  }
-  const hasCount = state === PHASE_STATE.open || state === PHASE_STATE.all
-  const cell = countCell(PHASE_MARK[state], hasCount ? countText(phase.done, phase.total) : BLANK_COUNT)
-  return current ? paint.bold(paint.yellow(cell)) : PHASE_PAINT[state](cell)
-}
-
 const agentLabel = (agent: string | null): string => {
   if (agent === null) return paint.dim(statusWord(agent))
   return isAgentStatus(agent) ? STATUS_PAINT[agent](statusWord(agent)) : statusWord(agent)
@@ -282,149 +191,6 @@ const gitLabel = (status: LaneStatus): string =>
     .filter(Boolean)
     .join(' ')
 
-const textFrame = (lines: string[]): Frame => ({ lines, cursorLine: -1, targets: [] })
-
-/** Stacks frames, moving each one's cursor line and click targets below the frames before it. */
-const joinFrames = (frames: Frame[]): Frame =>
-  frames.reduce<Frame>((joined, frame) => {
-    const offset = joined.lines.length
-    return {
-      lines: [...joined.lines, ...frame.lines],
-      cursorLine: frame.cursorLine === -1 ? joined.cursorLine : offset + frame.cursorLine,
-      targets: [...joined.targets, ...frame.targets.map((target) => ({ ...target, line: offset + target.line }))],
-    }
-  }, textFrame([]))
-
-/** The context of the children of a node: the pane minus the tree lines in front of them. */
-const deeper = <Context extends Pick<LaneContext, 'width'>>(context: Context): Context => ({
-  ...context,
-  width: Math.max(context.width - TREE_GUTTER, 1),
-})
-
-/**
- * A frame moved right by a prefix of `TREE_GUTTER` cells: a click target starting at the left edge keeps it and
- * takes the prefix in.
- */
-const prefixed = (frame: Frame, first: string, rest: string): Frame => ({
-  lines: frame.lines.map((line, index) => {
-    const lead = index === 0 ? first : rest
-    return line === '' ? paint.dim(lead.trimEnd()) : `${paint.dim(lead)}${line}`
-  }),
-  cursorLine: frame.cursorLine,
-  targets: frame.targets.map((target) => ({
-    ...target,
-    from: target.from === 0 ? 0 : target.from + TREE_GUTTER,
-    to: target.to + TREE_GUTTER,
-  })),
-})
-
-const branches = (children: Frame[]): Frame[] => {
-  const present = children.filter((child) => child.lines.length > 0)
-  return present.map((child, index) => {
-    const last = index === present.length - 1
-    return prefixed(child, last ? TREE.last : TREE.branch, last ? TREE.gap : TREE.pipe)
-  })
-}
-
-/**
- * The children of a node as a tree: each child's first line behind a branch, the last behind the closing one, the
- * lines of a child after its first beside the trunk. The caller has drawn the children `TREE_GUTTER` narrower
- * (`deeper`); a child without lines leaves no branch.
- */
-const nest = (children: Frame[]): Frame => joinFrames(branches(children))
-
-/** `nest` with a bare trunk line before every child, to set the children of the lane apart. */
-const nestSpaced = (children: Frame[]): Frame =>
-  joinFrames(branches(children).flatMap((child) => [textFrame([paint.dim(TREE.trunk)]), child]))
-
-/**
- * A row drawn inverse across the pane. A progress bar inside it is switched back to normal video: inverted,
- * its filled and empty blocks would trade places with the background and the bar would be unreadable.
- */
-const highlight = (line: string, width: number): string => {
-  const bars = line.match(BAR_SEGMENT) ?? []
-  const texts = line.split(BAR_SEGMENT).map(stripAnsi)
-  const body = texts.map((text, index) => `${text}${bars[index] ? `${bars[index]}${INVERSE_ON}` : ''}`).join('')
-  return `${INVERSE_ON}${body}${' '.repeat(Math.max(width - visibleLength(line), 0))}${RESET}`
-}
-
-/** A selectable row: drawn inverse when selected, clickable across the pane on every line, `below` follows unselectable. */
-const rowFrame = (
-  key: string,
-  rows: string[],
-  below: string[],
-  { state, width }: Pick<LaneContext, 'state' | 'width'>,
-): Frame => {
-  const selected = state.selected === key
-  return {
-    lines: [...(selected ? rows.map((row) => highlight(row, width)) : rows), ...below],
-    cursorLine: selected ? 0 : -1,
-    targets: rows.map((_, line) => ({ line, from: 0, to: width, key })),
-  }
-}
-
-/** `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)}`)
-
-/** 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 }
-}
-
-/** A closed task as one row, cut at the pane's edge with `…`. */
-const closedTaskRow = (item: ChecklistItem, active: boolean, width: number): string[] => {
-  const { mark, style } = taskLook(item, active)
-  return [fit(`${mark} ${style(plain(item.text))}`, 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 task as a selectable row under its `key`: clickable across every line it takes, the cursor on its first. */
-const taskFrame = (key: string, rows: string[], context: Pick<LaneContext, 'state' | 'width'>): Frame =>
-  rowFrame(key, rows, [], context)
-
-/** A checkbox moved to another phase, dim: `→ P9 <text>`. */
-const deferredRow = ({ text, target }: DeferredItem, width: number): string =>
-  fit(paint.dim(`${DEFERRED_MARK} ${PHASE_ID_PREFIX}${target} ${plain(text)}`), width)
-
-const tickedSummaryFrame = (count: number, phaseRowKey: string, width: number): Frame => ({
-  lines: [fit(paint.dim(`${chevronOf(false)} ${TEXTS.tickedSummary(count)}`), width)],
-  cursorLine: -1,
-  targets: [{ line: 0, from: 0, to: width, key: tickedKey(phaseRowKey) }],
-})
-
-/**
- * The children of an open phase, one frame per task: open ones first, `active` marked among them, then the ones
- * deferred to another phase, then the ticked ones listed or summed up.
- */
-const phaseChildren = (
-  context: StepContext,
-  phaseRowKey: string,
-  phase: PhaseProgress,
-  active: ChecklistItem | null,
-): Frame[] => {
-  const { state, width } = context
-  if (phase.items.length === 0 && !phase.deferred) return [textFrame([paint.dim(TEXTS.noCheckboxes)])]
-  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)
-    return taskFrame(key, rows, context)
-  }
-  const framesWhere = (done: boolean): Frame[] =>
-    phase.items.flatMap((item, index) => (item.done === done ? [frameOf(item, index)] : []))
-  const tickedCount = phase.items.filter((item) => item.done).length
-  const summary = tickedCount > 0 ? [tickedSummaryFrame(tickedCount, phaseRowKey, width)] : []
-  const deferred = (phase.deferred ?? []).map((item) => textFrame([deferredRow(item, width)]))
-  return [...framesWhere(false), ...deferred, ...(state.showDone ? framesWhere(true) : summary)]
-}
-
 /** A head in fixed columns with `text` wrapped beside it; follow-up lines indent to where the text starts. */
 const besideHead = (
   head: string,
@@ -459,70 +225,6 @@ export const rowWithCount = (
   )
 }
 
-/** ` ticked, not merged` in yellow behind a phase the lane ticked to the end in its worktree only; empty otherwise. Only the current phase carries it, the others fold into the ticked line. */
-const unmergedMark = (phase: PhaseProgress): string =>
-  isTickedUnmerged(phase) ? ` ${paint.yellow(TEXTS.tickedUnmerged)}` : ''
-
-/** The chevron of a phase row; a finished phase that is closed shows a green ✓ in its place. */
-const phaseMark = (phase: PhaseProgress, open: boolean): string =>
-  !open && phaseStateOf(phase) === PHASE_STATE.all ? paint.green(PHASE_COUNT.allTicked) : paint.dim(chevronOf(open))
-
-const familyLabel = (family: string): string => `${family.charAt(0).toUpperCase()}${family.slice(1)}`
-
-/**
- * The model the phase's subagent last ran on: `Opus ✓` when it fits the plan's recommendation, `Sonnet ≠ Opus` in
- * amber when it does not, the family alone, dim, when the plan recommends none; empty without a record.
- */
-const modelMark = (model: PhaseModel | undefined): string => {
-  if (!model) return ''
-  const used = familyLabel(model.used)
-  if (model.recommended === null) return paint.dim(used)
-  return model.fits
-    ? `${paint.dim(used)} ${paint.green(MODEL_MARK.fits)}`
-    : paint.yellow(`${used} ${MODEL_MARK.differs} ${familyLabel(model.recommended)}`)
-}
-
-/**
- * The phase title cut before the model and the count, which stay at the right edge, or the note that the plan lacks
- * the phase. The model gives way in a pane too narrow to leave the title `MIN_TITLE_WIDTH` cells.
- */
-const phaseRow = (phase: PhaseProgress, open: boolean, current: boolean, width: number, model?: PhaseModel): string => {
-  const title = phase.title === null ? paint.dim(TEXTS.notInPlan) : plain(phase.title)
-  const label = `${phaseMark(phase, open)} P${phase.id} `
-  const head = `${label}${title}${current ? unmergedMark(phase) : ''}`
-  const count = phaseCountCell(phase, current)
-  const withModel = `${modelMark(model)}${COLUMN_SEPARATOR}${count}`
-  const titleRoom = width - visibleLength(label) - visibleLength(withModel) - 1
-  const fitsModel =
-    model !== undefined && (titleRoom >= MIN_TITLE_WIDTH || titleRoom >= visibleLength(head) - visibleLength(label))
-  return spread(head, fitsModel ? withModel : count, width)
-}
-
-/** A closed phase shows only `active` under it, when given, closed whatever the task's fold. */
-const activeTaskFrame = (
-  context: StepContext,
-  phaseRowKey: string,
-  phase: PhaseProgress,
-  active: ChecklistItem | null,
-): Frame => {
-  if (!active) return textFrame([])
-  const key = itemKey(phaseRowKey, phase.items.indexOf(active))
-  return taskFrame(key, closedTaskRow(active, true, context.width), context)
-}
-
-/** One phase as a node, with its tasks below it when expanded, or its active task when it is the current one. */
-const phaseFrame = (context: StepContext, phase: PhaseProgress): Frame => {
-  const { progress, state, stepIndex, width } = context
-  const key = phaseKey(progress.lane.name, stepIndex, phase.id)
-  const open = state.expanded.has(key)
-  const current = isCurrent(progress, stepIndex, phase)
-  const inner = deeper(context)
-  const active = current ? activeItem(phase) : null
-  const children = open ? phaseChildren(inner, key, phase, active) : [activeTaskFrame(inner, key, phase, active)]
-  const model = context.models[phaseModelKey(stepIndex, phase.id)]
-  return joinFrames([rowFrame(key, [phaseRow(phase, open, current, width, model)], [], context), nest(children)])
-}
-
 /** True when number, checks and the badges leave room for a title beside them on one line. */
 const fitsBeside = (head: string, cells: BadgeCell[], width: number): boolean =>
   visibleLength(head) + packedWidth(cells) + COLUMN_SEPARATOR.length + MIN_TITLE_WIDTH <= width
@@ -538,7 +240,7 @@ const pullRequestRow = (pullRequest: PullRequest, context: LaneContext): Frame =
   const checksColumn =
     textWidth(checksWords) < CHECKS_WIDTH ? CHECKS_WIDTH : textWidth(checksWords) + COLUMN_SEPARATOR.length
   const checks = padVisible(CHECKS_PAINT[pullRequest.checks](checksWords), checksColumn)
-  const head = `${PULL_REQUEST_INDENT}${number}${COLUMN_SEPARATOR}${checks}`
+  const head = `${UNDER_STATUS}${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
@@ -547,7 +249,7 @@ const pullRequestRow = (pullRequest: PullRequest, context: LaneContext): Frame =
   if (cells.length === 0 || !fitsBeside(head, cells, context.width))
     return joinFrames([
       rowFrame(key, besideHead(head, `${prefix}${pullRequest.title}`, context.width, dimPrefix), [], context),
-      packedFrame(cells, PULL_REQUEST_INDENT, context.width),
+      packedFrame(cells, UNDER_STATUS, context.width),
     ])
   const beside = `${head}${cells.map(({ cell }) => cell).join(CHIP_GAP)}${COLUMN_SEPARATOR}`
   const row = rowFrame(
@@ -582,30 +284,35 @@ const CONTEXT_PAINT: Record<ContextLevel, (text: string) => string> = {
   [CONTEXT_LEVEL.alert]: paint.red,
 }
 
-/** `62 %` in the colour of its level, right-aligned in a fixed cell; empty when the lane has no reading. */
+/** `🥣 62 %`, the share in the colour of its level and right-aligned in a fixed cell; empty without a reading. */
+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
-    ? `${CONTEXT_SYMBOL}${CONTEXT_PAINT[context.level](contextLabel(context.share).padStart(CONTEXT_WIDTH))} ${paint.dim(COLUMN_RULE)} `
-    : ''
-
-/** Bar and count in a fixed-width column, so every bar on screen starts in the same column. */
-const progressColumn = (done: number, total: number): string =>
-  `${bar(done, total)} ${countCell(PROGRESS_SYMBOL, countText(done, total))}`
-
-/** Steps on the same plan share one group, wherever they stand in the lane, so a plan is headed once. */
-const groupSteps = (steps: readonly StepProgress[]): number[][] =>
-  steps.reduce<number[][]>((groups, { step }, index) => {
-    const same =
-      step.planHref === null ? undefined : groups.find((group) => steps[group[0]].step.planHref === step.planHref)
-    if (same) same.push(index)
-    else groups.push([index])
-    return groups
-  }, [])
+  context ? `${contextValue(context)} ${paint.dim(COLUMN_RULE)} ` : ''
+
+/**
+ * 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.
+ */
+const progressColumn = ({ done, total, phasesDone, phases }: LaneSummary['tally'], tallyWidth: number): string => {
+  const counts = `${bar(done, total)} ${countCell(PROGRESS_SYMBOL, countText(done, total))}`
+  if (tallyWidth === 0) return counts
+  const tally = TEXTS.phaseTally(phasesDone, phases)
+  const padding = ' '.repeat(Math.max(tallyWidth - visibleLength(tally), 0))
+  // A lane without phases keeps the column blank, so its bar starts where the others do.
+  const phaseCount = tally ? `${TALLY_SEPARATOR}${padding}${tally}` : ' '.repeat(TALLY_SEPARATOR.length + tallyWidth)
+  return `${counts}${paint.dim(phaseCount)}`
+}
 
 const CHIP_GAP = ' '
-const CHIP_MARK = '📎 '
+
 const TICKET_MARK = '📡'
 const STATUS_SEPARATOR = ' · '
+/** Between the checkbox count and the phase count of a lane. */
+const TALLY_SEPARATOR = ' · '
 
 /** `✦ label` as a badge linked to the chip's address, `private` faint after it for a link its plan says is private. */
 const chipCell = ({ url, icon, label, private: hidden }: LinkChip): string =>
@@ -672,16 +379,16 @@ const ticketCells = (tickets: LaneTickets | null): BadgeCell[] => {
 
 const chipCellOf = (chip: LinkChip): BadgeCell => ({ cell: chipCell(chip), key: chipKey(chip.url) })
 
-/** The chips of a plan behind a 📎, the plan chip first and the tickets beside it, then a blank line before the phases. */
+/** 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 => {
   const isPlanChip = (chip: LinkChip) => planUrlOf(chipKey(chip.url)) !== null
+  const unique = chips.filter((chip, index) => chips.findIndex(({ url }) => url === chip.url) === index)
   const cells = [
-    ...chips.filter(isPlanChip).map(chipCellOf),
+    ...unique.filter(isPlanChip).map(chipCellOf),
     ...ticketCells(tickets),
-    ...chips.filter((chip) => !isPlanChip(chip)).map(chipCellOf),
+    ...unique.filter((chip) => !isPlanChip(chip)).map(chipCellOf),
   ]
-  const frame = packedFrame(cells, CHIP_MARK, width)
-  return frame.lines.length > 0 ? { ...frame, lines: [...frame.lines, ''] } : frame
+  return packedFrame(cells, '', width)
 }
 
 /**
@@ -705,32 +412,22 @@ const badgeCells = (
   ]
 }
 
-const planHeading = (title: string, width: number): string[] => wrap(plain(title), width).map(paint.bold)
+/** 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))
 
 /**
- * A plan as a node: its title in bold, and below it the links and the phases in plan order, each ticked one as a
- * collapsed row of its own.
+ * 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.
  */
-const planBlock = (context: LaneContext, stepIndexes: number[], entries: PhaseEntry[]): Frame => {
-  const { progress, width, chips, tickets } = context
-  const { planTitle, planHref } = progress.steps[stepIndexes[0]].step
-  const inner = deeper(context)
-  return joinFrames([
-    textFrame(planHeading(planTitle, width)),
-    nest([
-      chipFrame(planHref ? (chips[planHref] ?? []) : [], tickets, inner.width),
-      ...entries.map(({ stepIndex, phase }) => phaseFrame({ ...inner, stepIndex }, phase)),
-    ]),
-  ])
+const headPhase = (view: LaneView): PhaseProgress | null => {
+  const current = currentPhase(view.progress)
+  return summaryOf(view).latest ?? (current && isPhaseOpen(current) ? current : null)
 }
 
-/** 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))
-
-/** `P9 Freigabe 0.x` for the current phase of a lane, marked when ticked and not merged; empty when there is none. */
-const nextPhaseLabel = ({ progress }: LaneView): string => {
-  const phase = currentPhase(progress)
-  return phase ? `P${phase.id}${phase.title ? ` ${plain(phase.title)}` : ''}${unmergedMark(phase)}` : ''
+/** `P9 Freigabe 0.x` 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)}` : ''}` : ''
 }
 
 const markTone = ({ feedback, changesRequested }: PullRequestBadges): BadgeTone => {
@@ -760,34 +457,54 @@ 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: git state while the lane is open, the next phase when folded. */
-const laneDetail = (view: LaneView, open: boolean): string => {
+/** 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 => {
   const markText = laneMarkText(view)
   const marker = markText ? paint.yellow(markText) : ''
-  return [marker, open ? gitLabel(view.status) : nextPhaseLabel(view)].filter(Boolean).join(' ')
+  return [marker, nextPhaseLabel(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, indented under the name and cut to the full width.
+ * 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.
  */
-export const withDetail = (head: string, detail: string, right: string, width: number): string[] => {
+export const withDetail = (
+  head: string,
+  detail: string,
+  right: string,
+  width: number,
+  indent = CONTENT_INDENT,
+): string[] => {
   if (!detail) return [spread(head, right, width)]
   const room = width - visibleLength(head) - COLUMN_SEPARATOR.length - visibleLength(right) - 1
   if (room >= MIN_BESIDE_WIDTH) return [spread(`${head}${COLUMN_SEPARATOR}${detail}`, right, width)]
-  return [spread(head, right, width), fit(`${CONTENT_INDENT}${detail}`, width)]
+  return [spread(head, right, width), fit(`${indent}${detail}`, width)]
+}
+
+/** 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)
+
+/** The bar 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) : ''
 }
 
-/** Context and bar at the right edge of a lane line, as wide as the lane has them. */
-const laneRight = (view: LaneView): string => {
-  const counts = view.progress.total > 0 ? progressColumn(view.progress.done, view.progress.total) : ''
+/** Context and bar at the right edge of a folded lane line, as wide as the lane has them. */
+const laneRight = (view: LaneView, tallyWidth: number): string => {
+  const counts = laneProgressColumn(view, tallyWidth)
   return counts ? `${contextCell(view.context)}${counts}` : contextCell(view.context).trimEnd()
 }
 
+/** 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). */
 const markedRight = (view: LaneView, columns: LaneColumns): string => {
-  const right = laneRight(view)
+  const right = laneRight(view, tallyWidthOf(columns))
   const marks = laneMarks(view)
   if (!marks) return right
   if (columns.right === 0) return padVisible(marks, columns.marks)
@@ -802,10 +519,39 @@ const laneLines = (view: LaneView, open: boolean, width: number, columns: LaneCo
     padVisible(agentLabel(status.agent), STATUS_WIDTH),
   ].join(COLUMN_SEPARATOR)
   const head = `${paint.dim(chevronOf(open))} ${symbolCell(status.agent)} ${cells}`
-  const right = open ? laneRight(view) : markedRight(view, columns)
-  return withDetail(head, laneDetail(view, open), right, width)
+  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,
+  )
+}
+
+/**
+ * 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)
+  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)
 }
 
+const underStatus = (frame: Frame): Frame =>
+  prefixed(frame, { first: UNDER_STATUS, rest: UNDER_STATUS, style: (text) => text })
+
+/** The chips of the plans the lane's steps name, in the order of its steps. */
+const laneChips = ({ progress, chips }: LaneView): LinkChip[] =>
+  progress.steps.flatMap(({ step }) => (step.planHref ? (chips[step.planHref] ?? []) : []))
+
 /** The lane line is a row of its own; an open lane continues with its pull requests and plans. */
 const laneBlock = (
   view: LaneView,
@@ -814,7 +560,7 @@ const laneBlock = (
   columns: LaneColumns,
   badgeTexts: BadgeTexts,
 ): Frame => {
-  const context = {
+  const context: LaneContext = {
     progress: view.progress,
     state,
     width,
@@ -827,22 +573,20 @@ const laneBlock = (
   const open = isLaneOpen(state, view.progress.lane.name, view.status.agent)
   const row = rowFrame(laneKey(view.progress.lane.name), laneLines(view, open, width, columns), [], context)
   if (!open) return row
-  const groups = groupSteps(view.progress.steps).map((stepIndexes) => ({
-    stepIndexes,
-    entries: stepIndexes.flatMap((stepIndex) =>
-      view.progress.steps[stepIndex].phases.map((phase) => ({ stepIndex, phase })),
-    ),
-  }))
-  const planned = groups.filter(({ entries }) => entries.length > 0)
-  const inner = deeper(context)
-  const content = nestSpaced([
-    ...(planned.length === 0 ? [chipFrame([], inner.tickets, inner.width)] : []),
-    ...planned.map(({ stepIndexes, entries }, index) =>
-      planBlock(index === 0 ? inner : { ...inner, tickets: null }, stepIndexes, entries),
-    ),
-    followingFrame(view, state, inner.width),
+  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 [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)),
   ])
-  return joinFrames([row, ...view.pullRequests.map((pullRequest) => pullRequestFrame(pullRequest, context)), content])
 }
 
 const laneTally = ({ progress }: Pick<LaneView, 'progress'>): string =>
@@ -901,21 +645,6 @@ const plannedRows = (planned: PlannedPlan[], width: number, indent: string): str
     ),
   )
 
-/** The plan title up to its subtitle: `Agent-Kit: Skills, Agenten und …` is `Agent-Kit`. */
-const planName = (title: string): string => plain(title.split(':')[0]).trim()
-
-/** The node under an open lane for the phases after its own: closed, `▸ also open: P7 P8`; opened, one child per plan. */
-const followingFrame = (view: LaneView, state: Selection, width: number): Frame => {
-  const following = view.following ?? []
-  if (following.length === 0) return textFrame([])
-  const key = followingKey(view.progress.lane.name)
-  const open = state.expanded.has(key)
-  const label = TEXTS.following(following.map((plan) => `${planName(plan.title)}: ${phaseList(plan)}`).join(' · '))
-  const head = [paint.dim(fit(`${chevronOf(open)} ${label}`, width))]
-  const plans = open ? plannedRows(following, deeper({ width }).width, '').map(textFrame) : []
-  return joinFrames([rowFrame(key, head, [], { state, width }), nest(plans)])
-}
-
 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. */
@@ -935,11 +664,26 @@ const watchNotice = (
   return watch.kind === WATCH_HEALTH.off ? texts.watcherOff : texts.stale(watch.minutes)
 }
 
-const laneColumnsOf = (lanes: LaneView[]): LaneColumns => ({
-  name: Math.min(Math.max(0, ...lanes.map(({ progress }) => textWidth(progress.lane.name))), NAME_WIDTH_MAX),
-  marks: Math.max(0, ...lanes.map((lane) => visibleLength(laneMarks(lane)))),
-  right: Math.max(0, ...lanes.map((lane) => visibleLength(laneRight(lane)))),
-})
+/** Chevron, symbol and the gaps around them before the name column of a lane line. */
+const LANE_HEAD_CELLS = 2 + SYMBOL_WIDTH + 1
+
+const laneColumnsOf = (lanes: LaneView[], width: number): LaneColumns => {
+  const name = Math.min(Math.max(0, ...lanes.map(({ progress }) => textWidth(progress.lane.name))), NAME_WIDTH_MAX)
+  const marks = Math.max(0, ...lanes.map((lane) => visibleLength(laneMarks(lane))))
+  const tally = Math.max(
+    0,
+    ...lanes.map((lane) => {
+      const { phasesDone, phases } = summaryOf(lane).tally
+      return visibleLength(TEXTS.phaseTally(phasesDone, phases))
+    }),
+  )
+  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 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 }
+}
 
 /** The lanes by what the view does with them; closed lanes are in none of the three groups. */
 const partitionLanes = (lanes: LaneView[]): Record<'active' | 'waiting' | 'noAgent', LaneView[]> => {
@@ -958,14 +702,14 @@ 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, language = PLAN_LANGUAGE.en }: OverviewView,
+  { title, time, lanes, planned, watch, watchesTickets }: OverviewView,
   state: Selection,
   width: number,
 ): Screen => {
   const { active, waiting, noAgent } = partitionLanes(lanes)
   const parked = [...waitingBlock(waiting, width), ...parkedBlock(noAgent, width)]
-  const columns = laneColumnsOf(active)
-  const badgeTexts = BADGE_TEXTS[language]
+  const columns = laneColumnsOf(active, width)
+  const badgeTexts = BADGE_TEXTS
   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)